diff --git a/.claude/commands/jspecify-annotate.md b/.claude/commands/jspecify-annotate.md
deleted file mode 100644
index 7083a6b3da..0000000000
--- a/.claude/commands/jspecify-annotate.md
+++ /dev/null
@@ -1,59 +0,0 @@
-The task is to annotate public API classes (marked with `@PublicAPI`) with JSpecify nullability annotations.
-
-Note that JSpecify is already used in this repository so it's already imported.
-
-If you see a builder static class, you can label it `@NullUnmarked` and not need to do anymore for this static class in terms of annotations.
-
-Analyze this Java class and add JSpecify annotations based on:
-1. Set the class to be `@NullMarked`
-2. Remove all the redundant `@NonNull` annotations that IntelliJ added
-3. Check Javadoc @param tags mentioning "null", "nullable", "may be null"
-4. Check Javadoc @return tags mentioning "null", "optional", "if available"
-5. Method implementations that return null or check for null
-6. GraphQL specification details (see details below)
-
-## GraphQL Specification Compliance
-This is a GraphQL implementation. When determining nullability, consult the GraphQL specification (https://spec.graphql.org/draft/) for the relevant concept. Key principles:
-
-The spec defines which elements are required (non-null) vs optional (nullable). Look for keywords like "MUST" to indicate when an element is required, and conditional words such as "IF" to indicate when an element is optional.
-
-If a class implements or represents a GraphQL specification concept, prioritize the spec's nullability requirements over what IntelliJ inferred.
-
-## How to validate
-Finally, please check all this works by running the NullAway compile check.
-
-If you find NullAway errors, try and make the smallest possible change to fix them. If you must, you can use assertNotNull. Make sure to include a message as well.
-
-## Formatting Guidelines
-
-Do not make spacing or formatting changes. Avoid adjusting whitespace, line breaks, or other formatting when editing code. These changes make diffs messy and harder to review. Only make the minimal changes necessary to accomplish the task.
-
-## Cleaning up
-Finally, can you remove this class from the JSpecifyAnnotationsCheck as an exemption
-
-You do not need to run the JSpecifyAnnotationsCheck. Removing the completed class is enough.
-
-Remember to delete all unused imports when you're done from the class you've just annotated.
-
-## Generics Annotations
-
-When annotating generic types and methods, follow these JSpecify rules:
-
-### Type Parameter Bounds
-
-The bound on a type parameter determines whether nullable type arguments are allowed:
-
-| Declaration | Allows `@Nullable` type argument? |
-|-------------|----------------------------------|
-| `<T>` | ❌ No — `Box<@Nullable String>` is illegal |
-| `<T extends @Nullable Object>` | ✅ Yes — `Box<@Nullable String>` is legal |
-
-**When to use `<T extends @Nullable Object>`:**
-- When callers genuinely need to parameterize with nullable types
-- Example: `DataFetcherResult<T extends @Nullable Object>` — data fetchers may return nullable types
-
-**When to keep `<T>`:**
-- When the type parameter represents a concrete non-null object
-- Even if some methods return `@Nullable T` (meaning "can be null even if T is non-null")
-- Example: `Edge<T>` with `@Nullable T getNode()` — node may be null, but T represents the object type
-
diff --git a/.gitattributes b/.gitattributes
new file mode 100644
index 0000000000..c1965c2162
--- /dev/null
+++ b/.gitattributes
@@ -0,0 +1 @@
+.github/workflows/*.lock.yml linguist-generated=true merge=ours
\ No newline at end of file
diff --git a/.githooks/pre-commit b/.githooks/pre-commit
index eee3d5d198..a01b246ca9 100755
--- a/.githooks/pre-commit
+++ b/.githooks/pre-commit
@@ -1,11 +1,14 @@
 #!/bin/bash
 
-# Pre-commit hook to enforce Windows compatibility and file size limits
+# Pre-commit hook to enforce Windows compatibility, file size limits,
+# and dangerous Unicode character detection.
 #
 # 1. Windows filenames: prevents characters that are reserved on Windows (< > : " | ? * \)
 #    so the repo can be cloned on Windows systems.
 # 2. File size: rejects files larger than 10 MB. Many enterprise users mirror graphql-java
 #    into internal repositories that enforce file size limits.
+# 3. Dangerous Unicode: detects invisible/control characters that can be used for
+#    "Trojan Source" (BiDi override), homoglyph, or glassworm-style attacks.
 
 # ANSI color codes for better output readability
 RED='\033[0;31m'
@@ -75,6 +78,45 @@ if [ -n "$LARGE_FILES" ]; then
     ERRORS_FOUND=1
 fi
 
+# Check 3: Dangerous Unicode characters (Trojan Source / glassworm attacks)
+# Detects: C0/C1 control chars (except TAB, LF, CR), zero-width characters,
+# BiDi override/embedding/isolate chars.
+# Uses perl for macOS compatibility (grep -P is not available on macOS).
+echo "  Checking for dangerous Unicode characters..."
+
+UNICODE_FILES=""
+if [ -n "$STAGED_FILES" ]; then
+    while IFS= read -r file; do
+        if [ ! -f "$file" ]; then
+            continue
+        fi
+        # Skip binary files
+        if file --mime-type "$file" 2>/dev/null | grep -qv 'text/'; then
+            continue
+        fi
+        MATCHES=$(perl -CSD -ne '
+            if (/[\x{0000}-\x{0008}\x{000B}\x{000C}\x{000E}-\x{001F}\x{007F}-\x{009F}\x{200B}-\x{200D}\x{FEFF}\x{202A}-\x{202E}\x{2066}-\x{2069}]/) {
+                print "    line $.: $_";
+            }
+        ' "$file" 2>/dev/null || true)
+        if [ -n "$MATCHES" ]; then
+            UNICODE_FILES="${UNICODE_FILES}  - ${file}\n${MATCHES}\n"
+        fi
+    done <<< "$STAGED_FILES"
+fi
+
+if [ -n "$UNICODE_FILES" ]; then
+    echo -e "${RED}Error: The following files contain dangerous Unicode characters:${NC}"
+    echo -e "$UNICODE_FILES"
+    echo -e "${YELLOW}These characters are invisible or alter text rendering and can be used for${NC}"
+    echo -e "${YELLOW}Trojan Source or glassworm-style attacks. Detected character categories:${NC}"
+    echo -e "${YELLOW}  - C0/C1 control characters (U+0000-001F, U+007F-009F, except TAB/LF/CR)${NC}"
+    echo -e "${YELLOW}  - Zero-width characters (U+200B-200D, U+FEFF)${NC}"
+    echo -e "${YELLOW}  - BiDi override/isolate (U+202A-202E, U+2066-2069)${NC}"
+    echo -e "${YELLOW}Please remove these characters from the affected files.${NC}"
+    ERRORS_FOUND=1
+fi
+
 # Exit with error if any checks failed
 if [ "$ERRORS_FOUND" -eq 1 ]; then
     echo -e "${RED}Pre-commit checks failed. Please fix the issues above and try again.${NC}"
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 10ef831183..f770db0a40 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -3,8 +3,8 @@ updates:
   - package-ecosystem: "gradle"
     directory: "/"
     schedule:
-      interval: "weekly"
+      interval: "monthly"
   - package-ecosystem: "github-actions"
     directory: "/"
     schedule:
-      interval: "weekly"
+      interval: "monthly"
diff --git a/.github/scripts/parse-jacoco.js b/.github/scripts/parse-jacoco.js
new file mode 100644
index 0000000000..4bf9a350cd
--- /dev/null
+++ b/.github/scripts/parse-jacoco.js
@@ -0,0 +1,103 @@
+// Shared JaCoCo XML parser used by CI workflows.
+// Extracts overall and per-class coverage counters from a JaCoCo XML report.
+
+const fs = require('fs');
+
+const zeroCov = { covered: 0, missed: 0 };
+
+function parseJacocoXml(jacocoFile) {
+  const result = { overall: {}, classes: {} };
+
+  if (!fs.existsSync(jacocoFile)) {
+    return null;
+  }
+
+  const xml = fs.readFileSync(jacocoFile, 'utf8');
+
+  // Overall counters (outside <package> tags)
+  const stripped = xml.replace(/<package[\s\S]*?<\/package>/g, '');
+  const re = /<counter type="(\w+)" missed="(\d+)" covered="(\d+)"\/>/g;
+  let m;
+  while ((m = re.exec(stripped)) !== null) {
+    const entry = { covered: parseInt(m[3]), missed: parseInt(m[2]) };
+    if (m[1] === 'LINE') result.overall.line = entry;
+    else if (m[1] === 'BRANCH') result.overall.branch = entry;
+    else if (m[1] === 'METHOD') result.overall.method = entry;
+  }
+
+  // Per-class counters from <package>/<class> elements.
+  // The negative lookbehind (?<!\/) prevents matching self-closing <class .../> tags
+  // (interfaces, annotations) which have no body and would otherwise steal the next
+  // class's counters.
+  const pkgRe = /<package\s+name="([^"]+)">([\s\S]*?)<\/package>/g;
+  let pkgMatch;
+  while ((pkgMatch = pkgRe.exec(xml)) !== null) {
+    const pkgBody = pkgMatch[2];
+    const classRe = /<class\s+name="([^"]+)"[^>]*(?<!\/)>([\s\S]*?)<\/class>/g;
+    let classMatch;
+    while ((classMatch = classRe.exec(pkgBody)) !== null) {
+      const className = classMatch[1].replace(/\//g, '.');
+      const classBody = classMatch[2];
+      const counters = { line: { ...zeroCov }, branch: { ...zeroCov }, method: { ...zeroCov } };
+      const cntRe = /<counter type="(\w+)" missed="(\d+)" covered="(\d+)"\/>/g;
+      let cntMatch;
+      while ((cntMatch = cntRe.exec(classBody)) !== null) {
+        const entry = { covered: parseInt(cntMatch[3]), missed: parseInt(cntMatch[2]) };
+        if (cntMatch[1] === 'LINE') counters.line = entry;
+        else if (cntMatch[1] === 'BRANCH') counters.branch = entry;
+        else if (cntMatch[1] === 'METHOD') counters.method = entry;
+      }
+      // Extract per-method counters within this class.
+      // JaCoCo XML contains <method name="..." desc="..." line="..."> elements
+      // each with their own <counter> children.
+      const methods = [];
+      const methodRe = /<method\s+name="([^"]+)"\s+desc="([^"]+)"(?:\s+line="(\d+)")?[^>]*>([\s\S]*?)<\/method>/g;
+      let methodMatch;
+      while ((methodMatch = methodRe.exec(classBody)) !== null) {
+        const mCounters = { line: { ...zeroCov }, branch: { ...zeroCov }, method: { ...zeroCov } };
+        const mCntRe = /<counter type="(\w+)" missed="(\d+)" covered="(\d+)"\/>/g;
+        let mCntMatch;
+        while ((mCntMatch = mCntRe.exec(methodMatch[4])) !== null) {
+          const entry = { covered: parseInt(mCntMatch[3]), missed: parseInt(mCntMatch[2]) };
+          if (mCntMatch[1] === 'LINE') mCounters.line = entry;
+          else if (mCntMatch[1] === 'BRANCH') mCounters.branch = entry;
+          else if (mCntMatch[1] === 'METHOD') mCounters.method = entry;
+        }
+        const totalLines = mCounters.line.covered + mCounters.line.missed;
+        if (totalLines > 0) {
+          methods.push({
+            name: methodMatch[1],
+            desc: methodMatch[2],
+            line: methodMatch[3] ? parseInt(methodMatch[3]) : null,
+            counters: mCounters,
+          });
+        }
+      }
+
+      // Skip classes with 0 total lines (empty interfaces, annotations)
+      if (counters.line.covered + counters.line.missed > 0) {
+        result.classes[className] = counters;
+        if (methods.length > 0) {
+          result.classes[className].methods = methods;
+        }
+      }
+    }
+  }
+
+  return result;
+}
+
+function pct(covered, missed) {
+  const total = covered + missed;
+  return total === 0 ? 0 : (covered / total * 100);
+}
+
+// A coverage metric is a "real regression" when BOTH the percentage drops
+// beyond the tolerance AND the absolute number of missed items increases.
+// This avoids false positives when well-covered code is extracted/moved out
+// of a class (which lowers the percentage without actually losing coverage).
+function isRegression(currPct, basePct, currMissed, baseMissed, tolerance = 0.05) {
+  return currPct < basePct - tolerance && currMissed > baseMissed;
+}
+
+module.exports = { parseJacocoXml, pct, zeroCov, isRegression };
diff --git a/.github/workflows/dependabot-auto-merge.yml b/.github/workflows/dependabot-auto-merge.yml
new file mode 100644
index 0000000000..8062f97978
--- /dev/null
+++ b/.github/workflows/dependabot-auto-merge.yml
@@ -0,0 +1,25 @@
+# Auto-merge Dependabot PRs after CI passes.
+# Triggers on push to dependabot/* branches so it does NOT appear as a PR check.
+name: Dependabot auto-merge
+on:
+  push:
+    branches:
+      - 'dependabot/**'
+
+permissions:
+  contents: write
+  pull-requests: write
+
+jobs:
+  dependabot:
+    runs-on: ubuntu-latest
+    if: github.actor == 'dependabot[bot]' && github.repository == 'graphql-java/graphql-java'
+    steps:
+      - name: Enable auto-merge for Dependabot PRs
+        run: |
+          PR_URL=$(gh pr list --head "$GITHUB_REF_NAME" --repo "$GITHUB_REPOSITORY" --json url --jq '.[0].url')
+          if [ -n "$PR_URL" ]; then
+            gh pr merge --auto --squash "$PR_URL"
+          fi
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
diff --git a/.github/workflows/master.yml b/.github/workflows/master.yml
index d6c53ecaac..1802aad061 100644
--- a/.github/workflows/master.yml
+++ b/.github/workflows/master.yml
@@ -4,38 +4,168 @@ on:
   push:
     branches:
       - master
-permissions: # For test summary bot
-  checks: write
+permissions:
+  contents: write
 jobs:
   buildAndTest:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        gradle-argument: [ 'assemble && ./gradlew check -x test','testWithJava11', 'testWithJava17','testWithJava21', 'test -x testWithJava11 -x testWithJava17 -x testWithJava21' ]
+        include:
+          - gradle-argument: 'assemble && ./gradlew check -x test -x testng'
+            label: 'check'
+          - gradle-argument: 'testWithJava11 testngWithJava11'
+            label: 'java11'
+            test-results-dirs: 'testWithJava11 testngWithJava11'
+          - gradle-argument: 'testWithJava17 testngWithJava17'
+            label: 'java17'
+            test-results-dirs: 'testWithJava17 testngWithJava17'
+          - gradle-argument: 'testWithJava21 testngWithJava21'
+            label: 'java21'
+            test-results-dirs: 'testWithJava21 testngWithJava21'
+          - gradle-argument: 'test testng jacocoTestReport'
+            label: 'java25'
+            test-results-dirs: 'test testng'
+          - gradle-argument: 'jcstress'
+            label: 'jcstress'
     steps:
       - uses: actions/checkout@v6
-      - uses: gradle/actions/wrapper-validation@v5
+      - uses: gradle/actions/wrapper-validation@v6
       - name: Set up JDK 25
         uses: actions/setup-java@v5
         with:
           java-version: '25'
           distribution: 'corretto'
       - name: build and test
-        run: ./gradlew ${{matrix.gradle-argument}} --info --stacktrace
-      - name: Publish Test Results
-        uses: EnricoMi/publish-unit-test-result-action@v2.23.0
-        if: always()
+        run: |
+          if [ "${{ matrix.label }}" = "jcstress" ]; then
+            set -o pipefail
+            mkdir -p build
+            ./gradlew ${{matrix.gradle-argument}} --info --stacktrace 2>&1 | tee build/jcstress-output.txt
+          else
+            ./gradlew ${{matrix.gradle-argument}} --info --stacktrace
+          fi
+      - name: Upload Coverage XML Report
+        uses: actions/upload-artifact@v7
+        if: always() && matrix.label == 'java25'
         with:
-          files: |
-            **/build/test-results/test/TEST-*.xml
-            **/build/test-results/testWithJava11/TEST-*.xml
-            **/build/test-results/testWithJava17/TEST-*.xml
-            **/build/test-results/testWithJava21/TEST-*.xml
+          name: coverage-report
+          path: build/reports/jacoco/test/jacocoTestReport.xml
+          retention-days: 1
+      - name: Parse Test Results
+        if: always() && matrix.label != 'check' && matrix.label != 'jcstress'
+        run: |
+          total=0; failures=0; errors=0; skipped=0
+          for dir_name in ${{ matrix.test-results-dirs }}; do
+            dir="build/test-results/$dir_name"
+            for f in "$dir"/TEST-*.xml; do
+              [ -f "$f" ] || continue
+              t=$(grep -o 'tests="[0-9]*"' "$f" | head -1 | grep -o '[0-9]*')
+              fl=$(grep -o 'failures="[0-9]*"' "$f" | head -1 | grep -o '[0-9]*')
+              e=$(grep -o 'errors="[0-9]*"' "$f" | head -1 | grep -o '[0-9]*')
+              s=$(grep -o 'skipped="[0-9]*"' "$f" | head -1 | grep -o '[0-9]*')
+              total=$((total + ${t:-0}))
+              failures=$((failures + ${fl:-0}))
+              errors=$((errors + ${e:-0}))
+              skipped=$((skipped + ${s:-0}))
+            done
+          done
+          passed=$((total - failures - errors - skipped))
+          mkdir -p /tmp/test-stats
+          echo "{\"total\":$total,\"passed\":$passed,\"failed\":$failures,\"errors\":$errors,\"skipped\":$skipped}" \
+            > "/tmp/test-stats/${{ matrix.label }}.json"
+      - name: Parse jcstress Results
+        if: always() && matrix.label == 'jcstress'
+        run: |
+          total=0; passed=0; failed=0; errors=0; skipped=0
+          if [ -f build/jcstress-output.txt ]; then
+            line=$(grep 'Results:.*planned.*passed.*failed' build/jcstress-output.txt | tail -1)
+            if [ -n "$line" ]; then
+              total=$(echo "$line" | sed 's/.*Results: \([0-9]*\) planned.*/\1/')
+              passed=$(echo "$line" | sed 's/.*; \([0-9]*\) passed.*/\1/')
+              failed=$(echo "$line" | sed 's/.*passed, \([0-9]*\) failed.*/\1/')
+              soft=$(echo "$line" | sed 's/.*failed, \([0-9]*\) soft.*/\1/')
+              hard=$(echo "$line" | sed 's/.*soft errs, \([0-9]*\) hard.*/\1/')
+              errors=$((soft + hard))
+            fi
+          fi
+          mkdir -p /tmp/test-stats
+          echo "{\"total\":$total,\"passed\":$passed,\"failed\":$failed,\"errors\":$errors,\"skipped\":$skipped}" \
+            > "/tmp/test-stats/${{ matrix.label }}.json"
+      - name: Upload Test Stats
+        if: always() && matrix.label != 'check'
+        uses: actions/upload-artifact@v7
+        with:
+          name: test-stats-${{ matrix.label }}
+          path: /tmp/test-stats/${{ matrix.label }}.json
+  update-baseline:
+    needs: buildAndTest
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+        with:
+          token: ${{ secrets.ADMIN_PAT }}
+      - name: Download Test Stats
+        uses: actions/download-artifact@v8
+        with:
+          pattern: test-stats-*
+          merge-multiple: true
+          path: test-stats/
+      - name: Download Coverage Report
+        uses: actions/download-artifact@v8
+        continue-on-error: true
+        with:
+          name: coverage-report
+          path: coverage/
+      - name: Update Baseline
+        uses: actions/github-script@v8
+        with:
+          script: |
+            const fs = require('fs');
+            const path = require('path');
+            const { parseJacocoXml } = require('./.github/scripts/parse-jacoco.js');
+
+            const versions = ['java11', 'java17', 'java21', 'java25', 'jcstress'];
+            const zeroTest = { total: 0, passed: 0, failed: 0, errors: 0, skipped: 0 };
+
+            // Read current baseline
+            const baselineFile = 'test-baseline.json';
+            let baseline = { tests: {}, coverage: {} };
+            if (fs.existsSync(baselineFile)) {
+              baseline = JSON.parse(fs.readFileSync(baselineFile, 'utf8'));
+            }
+
+            // Update test stats from artifacts
+            const tests = baseline.tests || {};
+            for (const v of versions) {
+              const file = path.join('test-stats', `${v}.json`);
+              if (fs.existsSync(file)) {
+                tests[v] = JSON.parse(fs.readFileSync(file, 'utf8'));
+              } else {
+                tests[v] = tests[v] || zeroTest;
+              }
+            }
+
+            // Update coverage from JaCoCo XML
+            const jacocoFile = path.join('coverage', 'jacocoTestReport.xml');
+            const coverage = parseJacocoXml(jacocoFile) || { overall: {}, classes: {} };
+
+            const updated = { tests, coverage };
+            fs.writeFileSync(baselineFile, JSON.stringify(updated, null, 2) + '\n');
+      - name: Commit Updated Baseline
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git add test-baseline.json
+          git diff --cached --quiet || {
+            git commit -m "Update test baseline [skip ci]"
+            git push
+          }
   javadoc:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v6
-      - uses: gradle/actions/wrapper-validation@v5
+      - uses: gradle/actions/wrapper-validation@v6
       - name: Set up JDK 25
         uses: actions/setup-java@v5
         with:
@@ -43,6 +173,34 @@ jobs:
           distribution: 'corretto'
       - name: Verify Javadoc
         run: ./gradlew javadoc --info --stacktrace
+  allBuildAndTestSuccessful:
+    if: always()
+    needs:
+      - buildAndTest
+      - update-baseline
+      - javadoc
+      - publishToMavenCentral
+    runs-on: ubuntu-latest
+    steps:
+      - name: Verify all jobs passed
+        run: |
+          if [ "${{ needs.buildAndTest.result }}" != "success" ]; then
+            echo "buildAndTest failed with result: ${{ needs.buildAndTest.result }}"
+            exit 1
+          fi
+          if [ "${{ needs.update-baseline.result }}" != "success" ]; then
+            echo "update-baseline failed with result: ${{ needs.update-baseline.result }}"
+            exit 1
+          fi
+          if [ "${{ needs.javadoc.result }}" != "success" ]; then
+            echo "javadoc failed with result: ${{ needs.javadoc.result }}"
+            exit 1
+          fi
+          if [ "${{ needs.publishToMavenCentral.result }}" != "success" ]; then
+            echo "publishToMavenCentral failed with result: ${{ needs.publishToMavenCentral.result }}"
+            exit 1
+          fi
+          echo "All build and test jobs passed successfully."
   publishToMavenCentral:
     needs: buildAndTest
     runs-on: ubuntu-latest
@@ -55,7 +213,7 @@ jobs:
 
     steps:
       - uses: actions/checkout@v6
-      - uses: gradle/actions/wrapper-validation@v5
+      - uses: gradle/actions/wrapper-validation@v6
       - name: Set up JDK 25
         uses: actions/setup-java@v5
         with:
diff --git a/.github/workflows/package.json b/.github/workflows/package.json
deleted file mode 100644
index 71ef804476..0000000000
--- a/.github/workflows/package.json
+++ /dev/null
@@ -1,14 +0,0 @@
-{
-  "name": "workflow-testrunner-tasksenqueuer",
-  "private": true,
-  "engines": {
-    "node": ">=12.0.0"
-  },
-  "files": [
-    "*.js"
-  ],
-  "dependencies": {
-    "@google-cloud/tasks": "^3.0.0",
-    "uuid": "^8.0.0"
-  }
-}
diff --git a/.github/workflows/pr-report.yml b/.github/workflows/pr-report.yml
new file mode 100644
index 0000000000..d80f9f3038
--- /dev/null
+++ b/.github/workflows/pr-report.yml
@@ -0,0 +1,385 @@
+name: PR Test Report
+# Posts test results and coverage as a PR comment.
+# Uses workflow_run so it has write permissions even for fork PRs.
+on:
+  workflow_run:
+    workflows: ["Pull Request Build"]
+    types: [completed]
+permissions:
+  pull-requests: write
+  actions: read
+jobs:
+  post-report:
+    if: >-
+      github.event.workflow_run.event == 'pull_request' &&
+      (github.event.workflow_run.conclusion == 'success' ||
+       github.event.workflow_run.conclusion == 'failure')
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - name: Download Test Stats
+        uses: actions/download-artifact@v8
+        continue-on-error: true
+        with:
+          pattern: test-stats-*
+          merge-multiple: true
+          path: test-stats/
+          run-id: ${{ github.event.workflow_run.id }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Download Coverage Report
+        uses: actions/download-artifact@v8
+        continue-on-error: true
+        with:
+          name: coverage-report
+          path: coverage/
+          run-id: ${{ github.event.workflow_run.id }}
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+      - name: Post Test Report Comment
+        uses: actions/github-script@v8
+        with:
+          script: |
+            const fs = require('fs');
+            const path = require('path');
+
+            // --- Find the PR number from the triggering workflow run ---
+            // payload.workflow_run.pull_requests is often empty, so fall back
+            // to searching by head branch + repo when needed.
+            let prNumber = (context.payload.workflow_run.pull_requests || [])[0]?.number;
+            if (!prNumber) {
+              const headBranch = context.payload.workflow_run.head_branch;
+              const headOwner = context.payload.workflow_run.head_repository.owner.login;
+              const { data: prs } = await github.rest.pulls.list({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                head: `${headOwner}:${headBranch}`,
+                state: 'open',
+              });
+              if (prs.length > 0) {
+                prNumber = prs[0].number;
+              }
+            }
+            if (!prNumber) {
+              console.log('No pull request associated with this workflow run, skipping.');
+              return;
+            }
+            console.log(`Posting report for PR #${prNumber}`);
+
+            const { parseJacocoXml, pct, zeroCov, isRegression } = require('./.github/scripts/parse-jacoco.js');
+
+            const versions = ['java11', 'java17', 'java21', 'java25', 'jcstress'];
+            const zeroTest = { total: 0, passed: 0, failed: 0, errors: 0, skipped: 0 };
+
+            // --- Read current test stats from artifacts ---
+            const current = {};
+            for (const v of versions) {
+              const file = path.join('test-stats', `${v}.json`);
+              if (fs.existsSync(file)) {
+                current[v] = JSON.parse(fs.readFileSync(file, 'utf8'));
+              } else {
+                current[v] = null;
+              }
+            }
+
+            // --- Read baseline from repo (read-only) ---
+            const baselineFile = 'test-baseline.json';
+            let baseline = { tests: {}, coverage: {} };
+            if (fs.existsSync(baselineFile)) {
+              baseline = JSON.parse(fs.readFileSync(baselineFile, 'utf8'));
+            }
+            const baseTests = baseline.tests || {};
+            const baseCov = (baseline.coverage || {}).overall || {};
+            const baseClasses = (baseline.coverage || {}).classes || {};
+
+            // --- Parse JaCoCo XML for coverage ---
+            const jacocoFile = path.join('coverage', 'jacocoTestReport.xml');
+            const parsed = parseJacocoXml(jacocoFile);
+            const covLine = parsed?.overall?.line || null;
+            const covBranch = parsed?.overall?.branch || null;
+            const covMethod = parsed?.overall?.method || null;
+            const classCounters = parsed?.classes || {};
+
+            // --- Helpers ---
+            function delta(curr, prev, positiveIsGood) {
+              const d = curr - prev;
+              if (d === 0) return '±0';
+              const str = d > 0 ? `+${d}` : `${d}`;
+              if (positiveIsGood === undefined) return str;
+              const icon = (positiveIsGood ? d > 0 : d < 0) ? ' 🟢' : ' 🔴';
+              return str + icon;
+            }
+
+            function fmtCell(curr, prev, positiveIsGood) {
+              return `${curr} (${delta(curr, prev, positiveIsGood)})`;
+            }
+
+            function fmtPct(value) {
+              return value.toFixed(1) + '%';
+            }
+
+            function fmtPctDelta(curr, prev) {
+              const d = curr - prev;
+              if (Math.abs(d) < 0.05) return '±0.0%';
+              const str = d > 0 ? `+${d.toFixed(1)}%` : `${d.toFixed(1)}%`;
+              const icon = d > 0 ? ' 🟢' : ' 🔴';
+              return str + icon;
+            }
+
+            // --- Build Test Results table ---
+            let body = '<!-- test-report -->\n## Test Report\n\n';
+            body += '### Test Results\n';
+            body += '| Java Version | Total | Passed | Failed | Errors | Skipped |\n';
+            body += '|:-------------|------:|-------:|-------:|-------:|--------:|\n';
+
+            for (const v of versions) {
+              const c = current[v] || zeroTest;
+              const b = baseTests[v] || zeroTest;
+              const label = v.replace('java', 'Java ');
+              if (!current[v]) {
+                body += `| ${label} | - | - | - | - | - |\n`;
+              } else {
+                body += `| ${label} | ${fmtCell(c.total, b.total, true)} | ${fmtCell(c.passed, b.passed, true)} | ${fmtCell(c.failed, b.failed, false)} | ${fmtCell(c.errors, b.errors, false)} | ${fmtCell(c.skipped, b.skipped)} |\n`;
+              }
+            }
+
+            const totalCurr = { ...zeroTest };
+            const totalBase = { ...zeroTest };
+            let hasAny = false;
+            for (const v of versions) {
+              if (current[v]) {
+                hasAny = true;
+                for (const k of Object.keys(zeroTest)) {
+                  totalCurr[k] += current[v][k];
+                  totalBase[k] += (baseTests[v] || zeroTest)[k];
+                }
+              }
+            }
+            if (hasAny) {
+              body += `| **Total** | **${fmtCell(totalCurr.total, totalBase.total, true)}** | **${fmtCell(totalCurr.passed, totalBase.passed, true)}** | **${fmtCell(totalCurr.failed, totalBase.failed, false)}** | **${fmtCell(totalCurr.errors, totalBase.errors, false)}** | **${fmtCell(totalCurr.skipped, totalBase.skipped)}** |\n`;
+            }
+
+            // --- Build Coverage table ---
+            if (covLine || covBranch || covMethod) {
+              body += '\n### Code Coverage (Java 25)\n';
+              body += '| Metric   | Covered | Missed | Coverage | vs Master |\n';
+              body += '|:---------|--------:|-------:|---------:|----------:|\n';
+
+              const metrics = [
+                { name: 'Lines', curr: covLine, baseKey: 'line' },
+                { name: 'Branches', curr: covBranch, baseKey: 'branch' },
+                { name: 'Methods', curr: covMethod, baseKey: 'method' },
+              ];
+
+              for (const { name, curr, baseKey } of metrics) {
+                if (!curr) continue;
+                const b = baseCov[baseKey] || zeroCov;
+                const currPct = pct(curr.covered, curr.missed);
+                const basePct = pct(b.covered, b.missed);
+                body += `| ${name} | ${curr.covered} | ${curr.missed} | ${fmtPct(currPct)} | ${fmtPctDelta(currPct, basePct)} |\n`;
+              }
+
+              body += '\n';
+
+              // --- Per-class coverage deltas ---
+              const changedClasses = [];
+              for (const [cls, curr] of Object.entries(classCounters)) {
+                const totalLines = curr.line.covered + curr.line.missed;
+                if (totalLines === 0) continue;
+                const base = baseClasses[cls] || { line: zeroCov, branch: zeroCov, method: zeroCov };
+                const currLinePct = pct(curr.line.covered, curr.line.missed);
+                const baseLinePct = pct(base.line.covered, base.line.missed);
+                const currBranchPct = pct(curr.branch.covered, curr.branch.missed);
+                const baseBranchPct = pct(base.branch.covered, base.branch.missed);
+                const currMethodPct = pct(curr.method.covered, curr.method.missed);
+                const baseMethodPct = pct(base.method.covered, base.method.missed);
+                // Check for improvements (positive delta) or real regressions (hybrid check)
+                const lineImproved = currLinePct > baseLinePct + 0.05;
+                const branchImproved = currBranchPct > baseBranchPct + 0.05;
+                const methodImproved = currMethodPct > baseMethodPct + 0.05;
+                const lineRegressed = isRegression(currLinePct, baseLinePct, curr.line.missed, base.line.missed);
+                const branchRegressed = isRegression(currBranchPct, baseBranchPct, curr.branch.missed, base.branch.missed);
+                const methodRegressed = isRegression(currMethodPct, baseMethodPct, curr.method.missed, base.method.missed);
+                if (lineImproved || branchImproved || methodImproved ||
+                    lineRegressed || branchRegressed || methodRegressed) {
+                  changedClasses.push({
+                    name: cls,
+                    linePct: currLinePct, lineDelta: currLinePct - baseLinePct,
+                    branchPct: currBranchPct, branchDelta: currBranchPct - baseBranchPct,
+                    methodPct: currMethodPct, methodDelta: currMethodPct - baseMethodPct,
+                    currMissed: { line: curr.line.missed, branch: curr.branch.missed, method: curr.method.missed },
+                    baseMissed: { line: base.line.missed, branch: base.branch.missed, method: base.method.missed },
+                    currMethods: curr.methods || [],
+                    baseMethods: base.methods || [],
+                  });
+                }
+              }
+              for (const cls of Object.keys(baseClasses)) {
+                const baseTotalLines = baseClasses[cls].line.covered + baseClasses[cls].line.missed;
+                if (baseTotalLines === 0) continue;
+                if (!classCounters[cls]) {
+                  changedClasses.push({
+                    name: cls,
+                    linePct: 0, lineDelta: -pct(baseClasses[cls].line.covered, baseClasses[cls].line.missed),
+                    branchPct: 0, branchDelta: -pct(baseClasses[cls].branch.covered, baseClasses[cls].branch.missed),
+                    methodPct: 0, methodDelta: -pct(baseClasses[cls].method.covered, baseClasses[cls].method.missed),
+                    removed: true,
+                  });
+                }
+              }
+
+              changedClasses.sort((a, b) => a.name.localeCompare(b.name));
+
+              function shortenClass(name) {
+                const dollarIdx = name.indexOf('$');
+                const mainPart = dollarIdx >= 0 ? name.substring(0, dollarIdx) : name;
+                const suffix = dollarIdx >= 0 ? name.substring(dollarIdx) : '';
+                const parts = mainPart.split('.');
+                const shortened = parts.map((p, i) => i < parts.length - 1 ? p[0] : p);
+                const result = shortened.join('.') + suffix;
+                return result.replace(/\$/g, '<br>\\$');
+              }
+
+              function fmtClassDelta(delta, currMissed, baseMissed) {
+                if (Math.abs(delta) < 0.05) return '±0.0%';
+                const str = delta > 0 ? `+${delta.toFixed(1)}%` : `${delta.toFixed(1)}%`;
+                if (delta > 0) return str + ' 🟢';
+                // Negative delta: only show as regression if missed count also increased
+                if (currMissed !== undefined && baseMissed !== undefined && currMissed <= baseMissed) {
+                  return '±0.0%';
+                }
+                return str + ' 🔴';
+              }
+
+              // Build a method-level detail block for classes with coverage decreases.
+              // Uses method name+desc as a stable key to match between baseline and current.
+              function buildMethodDetails(c) {
+                if (c.removed) return '';
+                // Only show method details for true regressions (hybrid check)
+                const lineRegressed = isRegression(c.linePct, c.linePct - c.lineDelta, c.currMissed.line, c.baseMissed.line);
+                const branchRegressed = isRegression(c.branchPct, c.branchPct - c.branchDelta, c.currMissed.branch, c.baseMissed.branch);
+                const methodRegressed = isRegression(c.methodPct, c.methodPct - c.methodDelta, c.currMissed.method, c.baseMissed.method);
+                if (!lineRegressed && !branchRegressed && !methodRegressed) return '';
+
+                const currMethods = c.currMethods || [];
+                const baseMethods = c.baseMethods || [];
+                if (currMethods.length === 0 && baseMethods.length === 0) return '';
+
+                // Index baseline methods by name+desc
+                const baseByKey = {};
+                for (const m of baseMethods) {
+                  baseByKey[m.name + m.desc] = m;
+                }
+
+                const rows = [];
+                const seen = new Set();
+                for (const m of currMethods) {
+                  const key = m.name + m.desc;
+                  seen.add(key);
+                  const bm = baseByKey[key];
+                  const currLinePct = pct(m.counters.line.covered, m.counters.line.missed);
+                  const baseLinePct = bm ? pct(bm.counters.line.covered, bm.counters.line.missed) : null;
+                  const currBranchTotal = m.counters.branch.covered + m.counters.branch.missed;
+                  const currBranchPct = currBranchTotal > 0 ? pct(m.counters.branch.covered, m.counters.branch.missed) : null;
+                  const baseBranchPct = bm ? (() => {
+                    const t = bm.counters.branch.covered + bm.counters.branch.missed;
+                    return t > 0 ? pct(bm.counters.branch.covered, bm.counters.branch.missed) : null;
+                  })() : null;
+
+                  // Show methods that actually changed coverage or are new/removed.
+                  // When baseline method data exists, only show methods whose coverage
+                  // moved — this avoids noise from methods that were already partially
+                  // covered. Fall back to showing all uncovered methods when no baseline
+                  // method data is available yet.
+                  const hasMissed = m.counters.line.missed > 0 || m.counters.branch.missed > 0;
+                  const lineChanged = baseLinePct !== null && Math.abs(currLinePct - baseLinePct) >= 0.05;
+                  const branchChanged = currBranchPct !== null && baseBranchPct !== null && Math.abs(currBranchPct - baseBranchPct) >= 0.05;
+                  const isNew = !bm;
+                  const show = baseMethods.length > 0
+                    ? (lineChanged || branchChanged || isNew)
+                    : (hasMissed || isNew);
+
+                  if (show) {
+                    let lineStr = fmtPct(currLinePct);
+                    if (baseLinePct !== null && Math.abs(currLinePct - baseLinePct) >= 0.05) {
+                      lineStr += ` (${fmtPctDelta(currLinePct, baseLinePct)})`;
+                    }
+                    let branchStr = currBranchPct !== null ? fmtPct(currBranchPct) : '—';
+                    if (currBranchPct !== null && baseBranchPct !== null && Math.abs(currBranchPct - baseBranchPct) >= 0.05) {
+                      branchStr += ` (${fmtPctDelta(currBranchPct, baseBranchPct)})`;
+                    }
+                    const tag = isNew ? ' **new**' : '';
+                    const displayName = m.name === '<init>' ? '*constructor*' : m.name;
+                    rows.push(`| ${displayName}${tag} | ${lineStr} | ${branchStr} |`);
+                  }
+                }
+                // Methods removed since baseline
+                for (const bm of baseMethods) {
+                  const key = bm.name + bm.desc;
+                  if (!seen.has(key)) {
+                    const displayName = bm.name === '<init>' ? '*constructor*' : bm.name;
+                    rows.push(`| ~~${displayName}~~ | *removed* | *removed* |`);
+                  }
+                }
+
+                if (rows.length === 0) return '';
+
+                const shortName = c.name.split('.').pop().replace(/\$/g, '.');
+                let detail = `\n<details>\n<summary>${shortName} — method details</summary>\n\n`;
+                detail += '| Method | Line | Branch |\n';
+                detail += '|:-------|-----:|-------:|\n';
+                detail += rows.join('\n') + '\n';
+                detail += '\n</details>\n';
+                return detail;
+              }
+
+              if (changedClasses.length > 0) {
+                body += `**Changed Class Coverage** (${changedClasses.length} ${changedClasses.length === 1 ? 'class' : 'classes'})\n\n`;
+                body += '| Class | Line | Branch | Method |\n';
+                body += '|:------|-----:|-------:|-------:|\n';
+                for (const c of changedClasses) {
+                  if (c.removed) {
+                    body += `| ${shortenClass(c.name)} | *removed* | *removed* | *removed* |\n`;
+                  } else {
+                    body += `| ${shortenClass(c.name)} | ${fmtClassDelta(c.lineDelta, c.currMissed.line, c.baseMissed.line)} | ${fmtClassDelta(c.branchDelta, c.currMissed.branch, c.baseMissed.branch)} | ${fmtClassDelta(c.methodDelta, c.currMissed.method, c.baseMissed.method)} |\n`;
+                  }
+                }
+                body += '\n';
+
+                // Add collapsible method-level details for classes with coverage decreases
+                for (const c of changedClasses) {
+                  body += buildMethodDetails(c);
+                }
+              } else {
+                body += '> No per-class coverage changes detected.\n';
+              }
+
+              body += '\n> Full HTML report: build artifact `jacoco-html-report`\n';
+            }
+
+            // Timestamp
+            const now = new Date().toISOString().replace('T', ' ').replace(/\.\d+Z$/, ' UTC');
+            body += `\n> *Updated: ${now}*\n`;
+
+            // --- Post or update single comment ---
+            const { data: comments } = await github.rest.issues.listComments({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: prNumber,
+            });
+            const marker = '<!-- test-report -->';
+            const existing = comments.find(c => c.body && c.body.startsWith(marker));
+            if (existing) {
+              await github.rest.issues.updateComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                comment_id: existing.id,
+                body,
+              });
+            } else {
+              await github.rest.issues.createComment({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: prNumber,
+                body,
+              });
+            }
+            console.log(`Posted test report comment on PR #${prNumber}`);
diff --git a/.github/workflows/pull_request.yml b/.github/workflows/pull_request.yml
index d80cee7e42..24f8d573a3 100644
--- a/.github/workflows/pull_request.yml
+++ b/.github/workflows/pull_request.yml
@@ -12,39 +12,212 @@ on:
       - 21.x
       - 20.x
       - 19.x
-permissions: # For test comment bot
-  checks: write
-  pull-requests: write
+permissions:
+  contents: read
 jobs:
   buildAndTest:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        gradle-argument: [ 'assemble && ./gradlew check -x test','testWithJava11', 'testWithJava17','testWithJava21', 'test -x testWithJava11 -x testWithJava17 -x testWithJava21' ]
+        include:
+          - gradle-argument: 'assemble && ./gradlew check -x test -x testng'
+            label: 'check'
+          - gradle-argument: 'testWithJava11 testngWithJava11'
+            label: 'java11'
+            test-results-dirs: 'testWithJava11 testngWithJava11'
+          - gradle-argument: 'testWithJava17 testngWithJava17'
+            label: 'java17'
+            test-results-dirs: 'testWithJava17 testngWithJava17'
+          - gradle-argument: 'testWithJava21 testngWithJava21'
+            label: 'java21'
+            test-results-dirs: 'testWithJava21 testngWithJava21'
+          - gradle-argument: 'test testng jacocoTestReport'
+            label: 'java25'
+            test-results-dirs: 'test testng'
+          - gradle-argument: 'jcstress'
+            label: 'jcstress'
     steps:
       - uses: actions/checkout@v6
-      - uses: gradle/actions/wrapper-validation@v5
+      - uses: gradle/actions/wrapper-validation@v6
       - name: Set up JDK 25
         uses: actions/setup-java@v5
         with:
           java-version: '25'
           distribution: 'corretto'
       - name: build and test
-        run: ./gradlew ${{matrix.gradle-argument}} --info --stacktrace
-      - name: Publish Test Results
-        uses: EnricoMi/publish-unit-test-result-action@v2.23.0
-        if: always()
+        run: |
+          if [ "${{ matrix.label }}" = "jcstress" ]; then
+            set -o pipefail
+            mkdir -p build
+            ./gradlew ${{matrix.gradle-argument}} --info --stacktrace 2>&1 | tee build/jcstress-output.txt
+          else
+            ./gradlew ${{matrix.gradle-argument}} --info --stacktrace
+          fi
+      - name: Upload Coverage HTML Report
+        uses: actions/upload-artifact@v7
+        if: always() && matrix.label == 'java25'
         with:
-          files: |
-            **/build/test-results/test/TEST-*.xml
-            **/build/test-results/testWithJava11/TEST-*.xml
-            **/build/test-results/testWithJava17/TEST-*.xml
-            **/build/test-results/testWithJava21/TEST-*.xml
+          name: jacoco-html-report
+          path: build/reports/jacoco/test/html/
+          retention-days: 14
+      - name: Upload Coverage XML Report
+        uses: actions/upload-artifact@v7
+        if: always() && matrix.label == 'java25'
+        with:
+          name: coverage-report
+          path: build/reports/jacoco/test/jacocoTestReport.xml
+          retention-days: 1
+      - name: Parse Test Results
+        if: always() && matrix.label != 'check' && matrix.label != 'jcstress'
+        run: |
+          total=0; failures=0; errors=0; skipped=0
+          for dir_name in ${{ matrix.test-results-dirs }}; do
+            dir="build/test-results/$dir_name"
+            for f in "$dir"/TEST-*.xml; do
+              [ -f "$f" ] || continue
+              t=$(grep -o 'tests="[0-9]*"' "$f" | head -1 | grep -o '[0-9]*')
+              fl=$(grep -o 'failures="[0-9]*"' "$f" | head -1 | grep -o '[0-9]*')
+              e=$(grep -o 'errors="[0-9]*"' "$f" | head -1 | grep -o '[0-9]*')
+              s=$(grep -o 'skipped="[0-9]*"' "$f" | head -1 | grep -o '[0-9]*')
+              total=$((total + ${t:-0}))
+              failures=$((failures + ${fl:-0}))
+              errors=$((errors + ${e:-0}))
+              skipped=$((skipped + ${s:-0}))
+            done
+          done
+          passed=$((total - failures - errors - skipped))
+          mkdir -p /tmp/test-stats
+          echo "{\"total\":$total,\"passed\":$passed,\"failed\":$failures,\"errors\":$errors,\"skipped\":$skipped}" \
+            > "/tmp/test-stats/${{ matrix.label }}.json"
+      - name: Parse jcstress Results
+        if: always() && matrix.label == 'jcstress'
+        run: |
+          total=0; passed=0; failed=0; errors=0; skipped=0
+          if [ -f build/jcstress-output.txt ]; then
+            line=$(grep 'Results:.*planned.*passed.*failed' build/jcstress-output.txt | tail -1)
+            if [ -n "$line" ]; then
+              total=$(echo "$line" | sed 's/.*Results: \([0-9]*\) planned.*/\1/')
+              passed=$(echo "$line" | sed 's/.*; \([0-9]*\) passed.*/\1/')
+              failed=$(echo "$line" | sed 's/.*passed, \([0-9]*\) failed.*/\1/')
+              soft=$(echo "$line" | sed 's/.*failed, \([0-9]*\) soft.*/\1/')
+              hard=$(echo "$line" | sed 's/.*soft errs, \([0-9]*\) hard.*/\1/')
+              errors=$((soft + hard))
+            fi
+          fi
+          mkdir -p /tmp/test-stats
+          echo "{\"total\":$total,\"passed\":$passed,\"failed\":$failed,\"errors\":$errors,\"skipped\":$skipped}" \
+            > "/tmp/test-stats/${{ matrix.label }}.json"
+      - name: Upload Test Stats
+        if: always() && matrix.label != 'check'
+        uses: actions/upload-artifact@v7
+        with:
+          name: test-stats-${{ matrix.label }}
+          path: /tmp/test-stats/${{ matrix.label }}.json
+  test-summary:
+    name: "Per-Class Coverage Gate"
+    needs: buildAndTest
+    if: always() && github.event_name == 'pull_request'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v6
+      - name: Download Coverage Report
+        uses: actions/download-artifact@v8
+        continue-on-error: true
+        with:
+          name: coverage-report
+          path: coverage/
+      - name: Enforce Per-Class Coverage Gate
+        uses: actions/github-script@v8
+        with:
+          script: |
+            const fs = require('fs');
+            const path = require('path');
+            const { parseJacocoXml, pct, zeroCov, isRegression } = require('./.github/scripts/parse-jacoco.js');
+
+            // --- Read baseline from repo ---
+            const baselineFile = 'test-baseline.json';
+            let baseline = { tests: {}, coverage: {} };
+            if (fs.existsSync(baselineFile)) {
+              baseline = JSON.parse(fs.readFileSync(baselineFile, 'utf8'));
+            }
+            const baseClasses = (baseline.coverage || {}).classes || {};
+
+            // --- Parse JaCoCo XML for per-class coverage ---
+            const jacocoFile = path.join('coverage', 'jacocoTestReport.xml');
+            const parsed = parseJacocoXml(jacocoFile);
+            if (!parsed) {
+              console.log('No JaCoCo report found, skipping coverage gate.');
+              return;
+            }
+            const classCounters = parsed.classes;
+
+            // --- Coverage gate: fail if any class regresses on any metric ---
+            // A regression requires BOTH a percentage drop AND an increase in the
+            // absolute number of missed items. This avoids false positives when
+            // well-covered code is extracted/moved out of a class (which lowers the
+            // percentage without actually losing any test coverage).
+            const regressions = [];
+            for (const [cls, curr] of Object.entries(classCounters)) {
+              const base = baseClasses[cls] || { line: zeroCov, branch: zeroCov, method: zeroCov };
+              const classRegressions = [];
+              for (const [metric, key] of [['Line', 'line'], ['Branch', 'branch'], ['Method', 'method']]) {
+                const currPct = pct(curr[key].covered, curr[key].missed);
+                const basePct = pct(base[key].covered, base[key].missed);
+                const currMissed = curr[key].missed;
+                const baseMissed = base[key].missed;
+                if (isRegression(currPct, basePct, currMissed, baseMissed)) {
+                  classRegressions.push(`  ${cls} ${metric}: ${currPct.toFixed(1)}% (was ${basePct.toFixed(1)}%, delta ${(currPct - basePct).toFixed(1)}%, missed: ${currMissed} was ${baseMissed})`);
+                }
+              }
+              if (classRegressions.length > 0) {
+                regressions.push(...classRegressions);
+                // Add method-level details for this regression
+                const currMethods = curr.methods || [];
+                const baseMethods = (base.methods || []);
+                if (currMethods.length > 0 || baseMethods.length > 0) {
+                  const baseByKey = {};
+                  for (const m of baseMethods) baseByKey[m.name + m.desc] = m;
+                  const seen = new Set();
+                  for (const m of currMethods) {
+                    const key = m.name + m.desc;
+                    seen.add(key);
+                    const bm = baseByKey[key];
+                    const currLinePct = pct(m.counters.line.covered, m.counters.line.missed);
+                    const baseLinePct = bm ? pct(bm.counters.line.covered, bm.counters.line.missed) : null;
+                    const lineChanged = baseLinePct !== null && Math.abs(currLinePct - baseLinePct) >= 0.05;
+                    const isNew = !bm;
+                    // When baseline method data exists, only show methods that actually
+                    // changed or are new. Fall back to showing all uncovered methods
+                    // when no baseline method data is available yet.
+                    const hasMissed = m.counters.line.missed > 0 || m.counters.branch.missed > 0;
+                    const show = baseMethods.length > 0
+                      ? (lineChanged || isNew)
+                      : (hasMissed || isNew);
+                    if (show) {
+                      const displayName = m.name === '<init>' ? 'constructor' : m.name;
+                      let detail = `      ${displayName} — Line: ${currLinePct.toFixed(1)}%`;
+                      if (baseLinePct !== null) detail += ` (was ${baseLinePct.toFixed(1)}%)`;
+                      else detail += ' (new)';
+                      regressions.push(detail);
+                    }
+                  }
+                  for (const bm of baseMethods) {
+                    if (!seen.has(bm.name + bm.desc)) {
+                      const displayName = bm.name === '<init>' ? 'constructor' : bm.name;
+                      regressions.push(`      ${displayName} — removed`);
+                    }
+                  }
+                }
+              }
+            }
+            if (regressions.length > 0) {
+              core.setFailed(`Per-class coverage regressions detected:\n${regressions.join('\n')}\n\nUpdate test-baseline.json if these changes are intentional.`);
+            }
   javadoc:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v6
-      - uses: gradle/actions/wrapper-validation@v5
+      - uses: gradle/actions/wrapper-validation@v6
       - name: Set up JDK 25
         uses: actions/setup-java@v5
         with:
@@ -52,3 +225,26 @@ jobs:
           distribution: 'corretto'
       - name: Verify Javadoc
         run: ./gradlew javadoc --info --stacktrace
+  allBuildAndTestSuccessful:
+    if: always()
+    needs:
+      - buildAndTest
+      - test-summary
+      - javadoc
+    runs-on: ubuntu-latest
+    steps:
+      - name: Verify all jobs passed
+        run: |
+          if [ "${{ needs.buildAndTest.result }}" != "success" ]; then
+            echo "buildAndTest failed with result: ${{ needs.buildAndTest.result }}"
+            exit 1
+          fi
+          if [ "${{ needs.test-summary.result }}" != "success" ] && [ "${{ needs.test-summary.result }}" != "skipped" ]; then
+            echo "Per-Class Coverage Gate failed with result: ${{ needs.test-summary.result }}"
+            exit 1
+          fi
+          if [ "${{ needs.javadoc.result }}" != "success" ]; then
+            echo "javadoc failed with result: ${{ needs.javadoc.result }}"
+            exit 1
+          fi
+          echo "All build and test jobs passed successfully."
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index 4e1d5fb29f..b63b039eb6 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -6,7 +6,8 @@ on:
       version:
         description: 'the version to be released'
         required: true
-
+permissions:
+  contents: read
 jobs:
   buildAndPublish:
     runs-on: ubuntu-latest
@@ -20,7 +21,7 @@ jobs:
 
     steps:
       - uses: actions/checkout@v6
-      - uses: gradle/actions/wrapper-validation@v5
+      - uses: gradle/actions/wrapper-validation@v6
       - name: Set up JDK 25
         uses: actions/setup-java@v5
         with:
diff --git a/.github/workflows/stale-pr-issue.yml b/.github/workflows/stale-pr-issue.yml
index f65cba3339..3e3242f2e8 100644
--- a/.github/workflows/stale-pr-issue.yml
+++ b/.github/workflows/stale-pr-issue.yml
@@ -8,7 +8,6 @@ on:
     - cron: '0 0 * * *'
 
 permissions:
-  actions: write
   issues: write
   pull-requests: write
 
diff --git a/.github/workflows/static.yml b/.github/workflows/static.yml
index 30353352ed..3a1e8bbebd 100644
--- a/.github/workflows/static.yml
+++ b/.github/workflows/static.yml
@@ -29,20 +29,20 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
-      - name: Set up JDK 21
-        uses: actions/setup-java@v4
+        uses: actions/checkout@v6
+      - name: Set up JDK 25
+        uses: actions/setup-java@v5
         with:
-          distribution: 'temurin'
-          java-version: '21'
+          distribution: 'corretto'
+          java-version: '25'
       - name: Generate performance page
         run: ./gradlew :performance-results-page:generatePerformancePage
       - name: Setup Pages
-        uses: actions/configure-pages@v5
+        uses: actions/configure-pages@v6
       - name: Upload artifact
-        uses: actions/upload-pages-artifact@v3
+        uses: actions/upload-pages-artifact@v4
         with:
           path: './performance-results-page/build/site'
       - name: Deploy to GitHub Pages
         id: deployment
-        uses: actions/deploy-pages@v4
+        uses: actions/deploy-pages@v5
diff --git a/.github/workflows/validate-files.yml b/.github/workflows/validate-files.yml
index 0852fade21..3c1cc83e61 100644
--- a/.github/workflows/validate-files.yml
+++ b/.github/workflows/validate-files.yml
@@ -5,6 +5,8 @@ name: Validate Files
 #    so the repo can be cloned on Windows systems.
 # 2. File size limits — no files larger than 10 MB. Many enterprise users mirror
 #    graphql-java into internal repositories that enforce file size limits.
+# 3. No dangerous Unicode characters — prevents Trojan Source (BiDi override),
+#    glassworm, and similar attacks using invisible or control characters.
 
 on:
   push:
@@ -19,11 +21,12 @@ on:
       - 21.x
       - 20.x
       - 19.x
-
+permissions:
+  contents: read
 jobs:
   validate-filenames-and-size:
     runs-on: ubuntu-latest
-    name: Validate Windows Compatibility and File Sizes
+    name: Validate Files (Windows names, size, Unicode safety)
     steps:
       - name: Checkout code
         uses: actions/checkout@v6
@@ -95,3 +98,53 @@ jobs:
           else
               echo "✓ All files are within the 10MB size limit"
           fi
+
+      - name: Check for dangerous Unicode characters
+        run: |
+          echo "Checking for dangerous Unicode characters (Trojan Source / glassworm)..."
+
+          # Dangerous character ranges:
+          #   U+0000-0008, U+000B-000C, U+000E-001F  C0 control chars (except TAB, LF, CR)
+          #   U+007F-009F                              DELETE + C1 control chars
+          #   U+200B-200D                              Zero-width space/non-joiner/joiner
+          #   U+FEFF                                   Zero-width no-break space (BOM)
+          #   U+202A-202E                              BiDi embedding/override (Trojan Source)
+          #   U+2066-2069                              BiDi isolate chars (Trojan Source)
+
+          FOUND_FILES=""
+
+          while IFS= read -r file; do
+              if [ ! -f "$file" ]; then
+                  continue
+              fi
+              # Skip binary files
+              if file --mime-type "$file" 2>/dev/null | grep -qv 'text/'; then
+                  continue
+              fi
+              MATCHES=$(perl -CSD -ne '
+                  if (/[\x{0000}-\x{0008}\x{000B}\x{000C}\x{000E}-\x{001F}\x{007F}-\x{009F}\x{200B}-\x{200D}\x{FEFF}\x{202A}-\x{202E}\x{2066}-\x{2069}]/) {
+                      print "  line $.: $_";
+                  }
+              ' "$file" 2>/dev/null || true)
+              if [ -n "$MATCHES" ]; then
+                  echo "::error file=${file}::File contains dangerous Unicode characters"
+                  FOUND_FILES="${FOUND_FILES}${file}:\n${MATCHES}\n"
+              fi
+          done <<< "$(git ls-files)"
+
+          if [ -n "$FOUND_FILES" ]; then
+              echo ""
+              echo "The following files contain dangerous Unicode characters:"
+              echo -e "$FOUND_FILES"
+              echo ""
+              echo "These invisible or rendering-altering characters can be used for"
+              echo "Trojan Source or glassworm-style attacks. Detected categories:"
+              echo "  - C0/C1 control characters (U+0000-001F, U+007F-009F, except TAB/LF/CR)"
+              echo "  - Zero-width characters (U+200B-200D, U+FEFF)"
+              echo "  - BiDi override/isolate (U+202A-202E, U+2066-2069)"
+              echo ""
+              echo "Please remove these characters from the affected files."
+              exit 1
+          else
+              echo "✓ No dangerous Unicode characters found"
+          fi
diff --git a/.gitignore b/.gitignore
index 24e536c805..fde13cfd1b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
+.claude/worktrees/
 *.iml
 *.ipr
 *.iws
@@ -16,4 +17,5 @@ docs/_build/
 /.nb-gradle/
 gen
 .DS_Store
-.vscode
\ No newline at end of file
+.vscode
+.claude/scheduled_tasks.lock
\ No newline at end of file
diff --git a/AGENTS.md b/AGENTS.md
index 369e771d62..d5e6e5dd61 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -1,11 +1,21 @@
 # AI Agent Context for graphql-java
 
-This file provides context for AI assistants working with this codebase.
+## Rules
 
-## Test Execution
+- **Tests in Spock (Groovy)**, not JUnit: `src/test/groovy/graphql/`
+- **No new dependencies** (firm policy)
+- **No wildcard imports**, no inner classes, no `Optional`
+- Max 2 indent levels; early returns; extract methods to reduce nesting
+- Immutable data classes w/ Builder: `newFoo()` factory, `foo(value)` setters, `transform()` method
+- Use `graphql.Assert` not `Objects.requireNonNull`
+- Use `@Public`/`@Internal` annotations — never package-private/protected
+- `@NullMarked` on all public API classes; `@NullUnmarked` on their Builder classes; use `@Nullable` for nullable params/returns; NullAway enforced via ErrorProne
+- Full style guide: `coding-guidelines.md`
 
-When running tests, exclude the Java version-specific test tasks to avoid failures:
+## Test Execution
 
 ```bash
-./gradlew test -x testWithJava21 -x testWithJava17 -x testWithJava11 -x testng
+./gradlew test
 ```
+
+This runs tests on Java 25 only. Other JVM versions (11, 17, 21) require explicit tasks (e.g. `testWithJava11`).
diff --git a/CLAUDE.md b/CLAUDE.md
new file mode 100644
index 0000000000..f4876c26ad
--- /dev/null
+++ b/CLAUDE.md
@@ -0,0 +1 @@
+See [AGENTS.md](AGENTS.md)
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 615cee2784..8896cf18c2 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -40,6 +40,8 @@ The pre-commit hook will automatically check for:
   - Splitting them into smaller parts (`.part1`, `.part2`, etc.)
   - Reducing the file size
 
+- **Dangerous Unicode characters**: Files containing invisible or rendering-altering Unicode characters will be rejected. This protects against [Trojan Source](https://trojansource.codes/) (BiDi override) and glassworm-style attacks. Blocked character categories include C0/C1 control characters, zero-width characters, and BiDi overrides.
+
 To bypass the hooks temporarily (not recommended), use `git commit --no-verify`.
 
 ### CI Validation
diff --git a/build.gradle b/build.gradle
index 9ad1a9cc2f..93a2bdb07e 100644
--- a/build.gradle
+++ b/build.gradle
@@ -5,26 +5,36 @@ import org.jetbrains.kotlin.gradle.dsl.KotlinVersion
 
 import java.text.SimpleDateFormat
 
+buildscript {
+    repositories { mavenCentral() }
+    dependencies {
+        classpath 'org.ow2.asm:asm:9.9.1'
+        classpath 'org.ow2.asm:asm-tree:9.9.1'
+    }
+}
+
 plugins {
     id 'java'
     id 'java-library'
     id 'maven-publish'
     id 'antlr'
     id 'signing'
-    id "com.gradleup.shadow" version "9.3.1"
+    id "com.gradleup.shadow" version "9.3.2"
     id "biz.aQute.bnd.builder" version "7.1.0"
     id "io.github.gradle-nexus.publish-plugin" version "2.0.0"
     id "groovy"
     id "me.champeau.jmh" version "0.7.3"
-    id "net.ltgt.errorprone" version '5.0.0'
+    id "io.github.reyerizo.gradle.jcstress" version "0.9.0"
+    id "net.ltgt.errorprone" version '5.1.0'
+    id 'jacoco'
     //
     // Kotlin just for tests - not production code
-    id 'org.jetbrains.kotlin.jvm' version '2.3.0'
+    id 'org.jetbrains.kotlin.jvm' version '2.3.20'
 }
 
 java {
     toolchain {
-        languageVersion = JavaLanguageVersion.of(21) // build on 21 - release on 11
+        languageVersion = JavaLanguageVersion.of(25) // build on 25 - release on 11
     }
 }
 
@@ -78,7 +88,7 @@ def getDevelopmentVersion() {
     def gitRevParseError = new StringBuilder()
     def gitRevParse = ["git", "-C", projectDir.toString(), "rev-parse", "--abbrev-ref", "HEAD"].execute()
     gitRevParse.waitForProcessOutput(gitRevParseOutput, gitRevParseError)
-    def branchName = gitRevParseOutput.toString().trim()
+    def branchName = gitRevParseOutput.toString().trim().replaceAll('[/\\\\]', '-')
 
     return makeDevelopmentVersion(["0.0.0", branchName, "SNAPSHOT"])
 }
@@ -127,13 +137,13 @@ dependencies {
     implementation 'org.antlr:antlr4-runtime:' + antlrVersion
     implementation 'com.google.guava:guava:' + guavaVersion
 
-    testImplementation 'org.junit.jupiter:junit-jupiter:5.14.1'
+    testImplementation 'org.junit.jupiter:junit-jupiter:5.14.3'
 
     testImplementation 'org.spockframework:spock-core:2.4-groovy-5.0'
-    testImplementation 'net.bytebuddy:byte-buddy:1.18.5'
+    testImplementation 'net.bytebuddy:byte-buddy:1.18.8'
     testImplementation 'org.objenesis:objenesis:3.5'
-    testImplementation 'org.apache.groovy:groovy:5.0.4'
-    testImplementation 'org.apache.groovy:groovy-json:5.0.4'
+    testImplementation 'org.apache.groovy:groovy:5.0.5'
+    testImplementation 'org.apache.groovy:groovy-json:5.0.5'
     testImplementation 'com.google.code.gson:gson:2.13.2'
     testImplementation 'org.eclipse.jetty:jetty-server:11.0.26'
     testImplementation 'com.fasterxml.jackson.core:jackson-databind:2.21.1'
@@ -142,27 +152,27 @@ dependencies {
 
     testImplementation 'org.reactivestreams:reactive-streams-tck:' + reactiveStreamsVersion
     testImplementation "io.reactivex.rxjava2:rxjava:2.2.21"
-    testImplementation "io.projectreactor:reactor-core:3.8.0"
+    testImplementation "io.projectreactor:reactor-core:3.8.4"
 
     testImplementation 'org.testng:testng:7.12.0' // use for reactive streams test inheritance
     testImplementation "com.tngtech.archunit:archunit-junit5:1.4.1"
     testImplementation 'org.openjdk.jmh:jmh-core:1.37' // required for ArchUnit to check JMH tests
     
     // JUnit Platform launcher required for Gradle 9
-    testRuntimeOnly 'org.junit.platform:junit-platform-launcher:1.14.1'
+    testRuntimeOnly 'org.junit.platform:junit-platform-launcher:1.14.3'
 
     antlr 'org.antlr:antlr4:' + antlrVersion
 
     // this is needed for the idea jmh plugin to work correctly
     jmh 'org.openjdk.jmh:jmh-core:1.37'
     jmh 'org.openjdk.jmh:jmh-generator-annprocess:1.37'
-    jmh 'me.bechberger:ap-loader-all:4.3-12'
+    jmh 'me.bechberger:ap-loader-all:4.3-13'
 
     // comment this in if you want to run JMH benchmarks from idea
 //    jmhAnnotationProcessor 'org.openjdk.jmh:jmh-generator-annprocess:1.37'
 
     errorprone 'com.uber.nullaway:nullaway:0.12.10'
-    errorprone 'com.google.errorprone:error_prone_core:2.47.0'
+    errorprone 'com.google.errorprone:error_prone_core:2.48.0'
 
     // just tests - no Kotlin otherwise
     testImplementation 'org.jetbrains.kotlin:kotlin-stdlib-jdk8'
@@ -224,6 +234,15 @@ tasks.named('jmhJar') {
     }
 }
 
+jcstress {
+}
+
+tasks.named('jcstress') {
+    javaLauncher = javaToolchains.launcherFor {
+        languageVersion = JavaLanguageVersion.of(25)
+    }
+}
+
 jmh {
     if (project.hasProperty('jmhInclude')) {
         includes = [project.property('jmhInclude')]
@@ -293,16 +312,105 @@ buildNewJar.dependsOn extractWithoutGuava
 shadowJar.finalizedBy extractWithoutGuava, buildNewJar
 
 
+// --- TestNG TCK skip verification ---
+// The Reactive Streams TCK PublisherVerification base class silently converts optional test
+// failures to skips. We verify the exact set of 49 expected skips after each testng run so
+// that a newly-silenced failure (or a newly-passing test) is caught immediately.
+
+def buildExpectedTestngSkips() {
+    def pkg = 'graphql.execution.reactive.tck.'
+    def allClasses = [
+            'CompletionStageMappingOrderedPublisherTckVerificationTest',
+            'CompletionStageMappingOrderedPublisherRandomCompleteTckVerificationTest',
+            'CompletionStageMappingPublisherTckVerificationTest',
+            'CompletionStageMappingPublisherRandomCompleteTckVerificationTest',
+            'SingleSubscriberPublisherTckVerificationTest',
+    ]
+    def multiSubscriberClasses = allClasses - ['SingleSubscriberPublisherTckVerificationTest']
+
+    // 8 methods skipped by all 5 classes (required_spec317 + 7 untested) = 40
+    def commonSkippedMethods = [
+            'required_spec317_mustNotSignalOnErrorWhenPendingAboveLongMaxValue',
+            'untested_spec106_mustConsiderSubscriptionCancelledAfterOnErrorOrOnCompleteHasBeenCalled',
+            'untested_spec107_mustNotEmitFurtherSignalsOnceOnErrorHasBeenSignalled',
+            'untested_spec108_possiblyCanceledSubscriptionShouldNotReceiveOnErrorOrOnCompleteSignals',
+            'untested_spec109_subscribeShouldNotThrowNonFatalThrowable',
+            'untested_spec110_rejectASubscriptionRequestIfTheSameSubscriberSubscribesTwice',
+            'untested_spec304_requestShouldNotPerformHeavyComputations',
+            'untested_spec305_cancelMustNotSynchronouslyPerformHeavyComputation',
+    ]
+
+    // 1 method skipped by 4 multi-subscriber classes = 4
+    def multiSubscriberSkippedMethods = [
+            'stochastic_spec103_mustSignalOnMethodsSequentially',
+    ]
+
+    // 5 methods skipped by SingleSubscriber only = 5
+    def singleSubscriberSkippedMethods = [
+            'optional_spec111_maySupportMultiSubscribe',
+            'optional_spec111_multicast_mustProduceTheSameElementsInTheSameSequenceToAllOfItsSubscribersWhenRequestingManyUpfront',
+            'optional_spec111_multicast_mustProduceTheSameElementsInTheSameSequenceToAllOfItsSubscribersWhenRequestingManyUpfrontAndCompleteAsExpected',
+            'optional_spec111_multicast_mustProduceTheSameElementsInTheSameSequenceToAllOfItsSubscribersWhenRequestingOneByOne',
+            'optional_spec111_registeredSubscribersMustReceiveOnNextOrOnCompleteSignals',
+    ]
+
+    def expected = [] as Set<String>
+    allClasses.each { cls ->
+        commonSkippedMethods.each { method -> expected.add(pkg + cls + '.' + method) }
+    }
+    multiSubscriberClasses.each { cls ->
+        multiSubscriberSkippedMethods.each { method -> expected.add(pkg + cls + '.' + method) }
+    }
+    singleSubscriberSkippedMethods.each { method ->
+        expected.add(pkg + 'SingleSubscriberPublisherTckVerificationTest.' + method)
+    }
+    return expected  // 40 + 4 + 5 = 49
+}
+
+def verifyTestngSkips(Task task, Set<String> expected) {
+    def xmlDir = task.reports.junitXml.outputLocation.asFile.get()
+    def actualSkips = [] as Set<String>
+    xmlDir.eachFileMatch(~/TEST-.*\.xml/) { file ->
+        def testsuite = new groovy.xml.XmlSlurper().parse(file)
+        testsuite.testcase.each { tc ->
+            if (tc.skipped.size() > 0) {
+                actualSkips.add(tc.@classname.toString() + '.' + tc.@name.toString())
+            }
+        }
+    }
+
+    def unexpected = actualSkips - expected
+    def missing = expected - actualSkips
+    if (unexpected || missing) {
+        def msg = new StringBuilder("TestNG TCK skip verification failed!\n")
+        if (unexpected) {
+            msg.append("\nUnexpected skips (tests that should pass but were skipped):\n")
+            unexpected.toSorted().each { msg.append("  + ${it}\n") }
+        }
+        if (missing) {
+            msg.append("\nMissing skips (tests that should be skipped but were not):\n")
+            missing.toSorted().each { msg.append("  - ${it}\n") }
+        }
+        msg.append("\nUpdate buildExpectedTestngSkips() in build.gradle if these changes are intentional.")
+        throw new GradleException(msg.toString())
+    }
+    logger.lifecycle("TestNG TCK skip verification passed: ${actualSkips.size()} skips match expected set.")
+}
+
+def expectedTestngSkips = buildExpectedTestngSkips()
+
 task testng(type: Test) {
     useTestNG()
+    testClassesDirs = sourceSets.test.output.classesDirs
+    classpath = sourceSets.test.runtimeClasspath
+    dependsOn tasks.named('testClasses')
+    doLast { verifyTestngSkips(it, expectedTestngSkips) }
 }
-check.dependsOn testng
-
 compileJava {
     options.compilerArgs += ["-parameters"]
     source file("build/generated-src"), sourceSets.main.java
     // Gradle 9 requires explicit task dependencies
-    mustRunAfter generateTestGrammarSource, generateJmhGrammarSource
+    mustRunAfter generateTestGrammarSource, generateJmhGrammarSource, generateJcstressGrammarSource
 }
 
 tasks.withType(GroovyCompile) {
@@ -328,7 +436,7 @@ tasks.withType(JavaCompile) {
         option("NullAway:JSpecifyMode", "true")
     }
     // Include to disable NullAway on test code
-    if (name.toLowerCase().contains("test")) {
+    if (name.toLowerCase().contains("test") || name.toLowerCase().contains("jcstress")) {
         options.errorprone {
             disable("NullAway")
         }
@@ -371,7 +479,10 @@ int testCount = 0
 long testTime = 0L
 
 tasks.withType(Test) {
-    useJUnitPlatform()
+    if (!name.startsWith('testng')) {
+        useJUnitPlatform()
+    }
+    maxHeapSize = "1g"
     testLogging {
         events "FAILED", "SKIPPED"
         exceptionFormat = "FULL"
@@ -437,10 +548,116 @@ tasks.register('testWithJava11', Test) {
 
 }
 
-test.dependsOn testWithJava21
-test.dependsOn testWithJava17
-test.dependsOn testWithJava11
+['11', '17', '21'].each { ver ->
+    tasks.register("testngWithJava${ver}", Test) {
+        useTestNG()
+        javaLauncher = javaToolchains.launcherFor {
+            languageVersion = JavaLanguageVersion.of(ver)
+        }
+        testClassesDirs = sourceSets.test.output.classesDirs
+        classpath = sourceSets.test.runtimeClasspath
+        dependsOn tasks.named('testClasses')
+        doLast { verifyTestngSkips(it, expectedTestngSkips) }
+    }
+}
+
+
+jacoco {
+    toolVersion = "0.8.14"
+}
+
+jacocoTestReport {
+    dependsOn test
+    reports {
+        xml.required = true
+        html.required = true
+        csv.required = false
+    }
+
+    // Use the modified classes from classes-jacoco/ (with @Generated annotations)
+    // so CRC64 checksums match the execution data recorded during tests.
+    // Also exclude generated ANTLR code and shaded dependencies from coverage.
+    afterEvaluate {
+        classDirectories.setFrom(files(
+                fileTree(dir: layout.buildDirectory.dir('classes-jacoco/java/main'), exclude: [
+                        'graphql/parser/antlr/**',
+                        'graphql/com/google/**',
+                        'graphql/org/antlr/**'
+                ])
+        ))
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Mark identity equals(Object)/hashCode() with a @Generated annotation so
+// JaCoCo's AnnotationGeneratedFilter excludes them from coverage.
+// The annotation class need not exist — JaCoCo only inspects the descriptor
+// string in the bytecode, and the JVM ignores unknown CLASS-retention
+// annotations.
+//
+// IMPORTANT: modifications are made on a COPY in classes-jacoco/ so that
+// the original (pristine) class files in classes/java/main are packaged
+// into the published jar unchanged.
+// ---------------------------------------------------------------------------
+tasks.register('markGeneratedEqualsHashCode') {
+    description = 'Add @Generated annotation to equals/hashCode so JaCoCo ignores them'
+    dependsOn classes
+
+    def originalDir = layout.buildDirectory.dir('classes/java/main')
+    def jacocoDir = layout.buildDirectory.dir('classes-jacoco/java/main')
+
+    inputs.dir(originalDir)
+    outputs.dir(jacocoDir)
+
+    doLast {
+        def src = originalDir.get().asFile
+        def dest = jacocoDir.get().asFile
+        if (!src.exists()) return
+
+        // Copy all class files to a separate directory for JaCoCo
+        ant.copy(todir: dest) {
+            fileset(dir: src)
+        }
 
+        def ANNOTATION = 'Lgraphql/coverage/Generated;'
+
+        dest.eachFileRecurse(groovy.io.FileType.FILES) { file ->
+            if (!file.name.endsWith('.class')) return
+
+            def bytes = file.bytes
+            def classNode = new org.objectweb.asm.tree.ClassNode()
+            new org.objectweb.asm.ClassReader(bytes).accept(classNode, 0)
+
+            boolean modified = false
+            for (method in classNode.methods) {
+                if ((method.name == 'equals' && method.desc == '(Ljava/lang/Object;)Z') ||
+                        (method.name == 'hashCode' && method.desc == '()I')) {
+                    if (method.invisibleAnnotations == null) {
+                        method.invisibleAnnotations = []
+                    }
+                    method.invisibleAnnotations.add(new org.objectweb.asm.tree.AnnotationNode(ANNOTATION))
+                    modified = true
+                }
+            }
+
+            if (modified) {
+                def writer = new org.objectweb.asm.ClassWriter(0)
+                classNode.accept(writer)
+                file.bytes = writer.toByteArray()
+            }
+        }
+    }
+}
+
+// Test tasks need the modified classes for JaCoCo coverage recording
+tasks.named('test') { dependsOn markGeneratedEqualsHashCode }
+tasks.named('compileTestJava') { dependsOn markGeneratedEqualsHashCode }
+
+// Prepend modified classes to the test classpath so the JaCoCo agent records
+// execution data with CRC64s that match the annotated bytecode.
+tasks.named('test', Test) {
+    classpath = files(layout.buildDirectory.dir('classes-jacoco/java/main')) + classpath
+}
 
 /*
  * The gradle.buildFinished callback is deprecated BUT there does not seem to be a decent alternative in gradle 7
diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar
index 61285a659d..d997cfc60f 100644
Binary files a/gradle/wrapper/gradle-wrapper.jar and b/gradle/wrapper/gradle-wrapper.jar differ
diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties
index 37f78a6af8..dbc3ce4a04 100644
--- a/gradle/wrapper/gradle-wrapper.properties
+++ b/gradle/wrapper/gradle-wrapper.properties
@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.3.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-9.4.0-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME
diff --git a/gradlew b/gradlew
index adff685a03..0262dcbd52 100755
--- a/gradlew
+++ b/gradlew
@@ -57,7 +57,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/b631911858264c0b6e4d6603d677ff5218766cee/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 #       within the Gradle project.
 #
 #       You can find Gradle at https://github.com/gradle/gradle/.
diff --git a/src/jcstress/java/graphql/execution/reactive/CompletionStageOrderedSubscriber_onComplete_JCStress.java b/src/jcstress/java/graphql/execution/reactive/CompletionStageOrderedSubscriber_onComplete_JCStress.java
new file mode 100644
index 0000000000..56edfc72b1
--- /dev/null
+++ b/src/jcstress/java/graphql/execution/reactive/CompletionStageOrderedSubscriber_onComplete_JCStress.java
@@ -0,0 +1,94 @@
+package graphql.execution.reactive;
+
+import org.openjdk.jcstress.annotations.Actor;
+import org.openjdk.jcstress.annotations.Arbiter;
+import org.openjdk.jcstress.annotations.Expect;
+import org.openjdk.jcstress.annotations.JCStressTest;
+import org.openjdk.jcstress.annotations.Outcome;
+import org.openjdk.jcstress.annotations.State;
+import org.openjdk.jcstress.infra.results.II_Result;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+
+/**
+ * Exercises the race between the last CompletableFuture completing (Actor 1)
+ * and onComplete() being called (Actor 2) in {@link CompletionStageOrderedSubscriber}.
+ * <p>
+ * The ordered subscriber has a different whenNextFinished path that calls
+ * emptyInFlightQueueIfWeCan() under lock, exercising a different code path
+ * for the same race window.
+ * <p>
+ * Before the fix, this race could cause onComplete to be stranded (never called
+ * on the downstream subscriber), resulting in outcome (1, 0). After the fix,
+ * the only acceptable outcome is (1, 1).
+ */
+@JCStressTest
+@Outcome(id = "1, 1", expect = Expect.ACCEPTABLE, desc = "onNext and onComplete both delivered")
+@Outcome(id = "1, 0", expect = Expect.FORBIDDEN, desc = "onComplete lost — race condition bug")
+@State
+public class CompletionStageOrderedSubscriber_onComplete_JCStress {
+
+    private final CompletableFuture<String> future = new CompletableFuture<>();
+    private final AtomicInteger onNextCount = new AtomicInteger();
+    private final AtomicInteger onCompleteCount = new AtomicInteger();
+    private final CompletionStageOrderedSubscriber<Integer, String> subscriber;
+
+    public CompletionStageOrderedSubscriber_onComplete_JCStress() {
+        Function<Integer, CompletionStage<String>> mapper = i -> future;
+
+        Subscriber<String> downstream = new Subscriber<String>() {
+            @Override
+            public void onSubscribe(Subscription s) {
+            }
+
+            @Override
+            public void onNext(String s) {
+                onNextCount.incrementAndGet();
+            }
+
+            @Override
+            public void onError(Throwable t) {
+            }
+
+            @Override
+            public void onComplete() {
+                onCompleteCount.incrementAndGet();
+            }
+        };
+
+        subscriber = new CompletionStageOrderedSubscriber<>(mapper, downstream);
+
+        // Wire up subscription and enqueue one in-flight CF
+        subscriber.onSubscribe(new Subscription() {
+            @Override
+            public void request(long n) {
+            }
+
+            @Override
+            public void cancel() {
+            }
+        });
+        subscriber.onNext(1);
+    }
+
+    @Actor
+    public void actor1() {
+        future.complete("value");
+    }
+
+    @Actor
+    public void actor2() {
+        subscriber.onComplete();
+    }
+
+    @Arbiter
+    public void arbiter(II_Result r) {
+        r.r1 = onNextCount.get();
+        r.r2 = onCompleteCount.get();
+    }
+}
diff --git a/src/jcstress/java/graphql/execution/reactive/CompletionStageSubscriber_onComplete_JCStress.java b/src/jcstress/java/graphql/execution/reactive/CompletionStageSubscriber_onComplete_JCStress.java
new file mode 100644
index 0000000000..88aee26917
--- /dev/null
+++ b/src/jcstress/java/graphql/execution/reactive/CompletionStageSubscriber_onComplete_JCStress.java
@@ -0,0 +1,90 @@
+package graphql.execution.reactive;
+
+import org.openjdk.jcstress.annotations.Actor;
+import org.openjdk.jcstress.annotations.Arbiter;
+import org.openjdk.jcstress.annotations.Expect;
+import org.openjdk.jcstress.annotations.JCStressTest;
+import org.openjdk.jcstress.annotations.Outcome;
+import org.openjdk.jcstress.annotations.State;
+import org.openjdk.jcstress.infra.results.II_Result;
+import org.reactivestreams.Subscriber;
+import org.reactivestreams.Subscription;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionStage;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+
+/**
+ * Exercises the race between the last CompletableFuture completing (Actor 1)
+ * and onComplete() being called (Actor 2) in {@link CompletionStageSubscriber}.
+ * <p>
+ * Before the fix, this race could cause onComplete to be stranded (never called
+ * on the downstream subscriber), resulting in outcome (1, 0). After the fix,
+ * the only acceptable outcome is (1, 1).
+ */
+@JCStressTest
+@Outcome(id = "1, 1", expect = Expect.ACCEPTABLE, desc = "onNext and onComplete both delivered")
+@Outcome(id = "1, 0", expect = Expect.FORBIDDEN, desc = "onComplete lost — race condition bug")
+@State
+public class CompletionStageSubscriber_onComplete_JCStress {
+
+    private final CompletableFuture<String> future = new CompletableFuture<>();
+    private final AtomicInteger onNextCount = new AtomicInteger();
+    private final AtomicInteger onCompleteCount = new AtomicInteger();
+    private final CompletionStageSubscriber<Integer, String> subscriber;
+
+    public CompletionStageSubscriber_onComplete_JCStress() {
+        Function<Integer, CompletionStage<String>> mapper = i -> future;
+
+        Subscriber<String> downstream = new Subscriber<String>() {
+            @Override
+            public void onSubscribe(Subscription s) {
+            }
+
+            @Override
+            public void onNext(String s) {
+                onNextCount.incrementAndGet();
+            }
+
+            @Override
+            public void onError(Throwable t) {
+            }
+
+            @Override
+            public void onComplete() {
+                onCompleteCount.incrementAndGet();
+            }
+        };
+
+        subscriber = new CompletionStageSubscriber<>(mapper, downstream);
+
+        // Wire up subscription and enqueue one in-flight CF
+        subscriber.onSubscribe(new Subscription() {
+            @Override
+            public void request(long n) {
+            }
+
+            @Override
+            public void cancel() {
+            }
+        });
+        subscriber.onNext(1);
+    }
+
+    @Actor
+    public void actor1() {
+        future.complete("value");
+    }
+
+    @Actor
+    public void actor2() {
+        subscriber.onComplete();
+    }
+
+    @Arbiter
+    public void arbiter(II_Result r) {
+        r.r1 = onNextCount.get();
+        r.r2 = onCompleteCount.get();
+    }
+}
diff --git a/src/main/java/graphql/ExceptionWhileDataFetching.java b/src/main/java/graphql/ExceptionWhileDataFetching.java
index d5d0c61379..89a13d9649 100644
--- a/src/main/java/graphql/ExceptionWhileDataFetching.java
+++ b/src/main/java/graphql/ExceptionWhileDataFetching.java
@@ -27,7 +27,7 @@ public class ExceptionWhileDataFetching implements GraphQLError {
     private final List<SourceLocation> locations;
     private final @Nullable Map<String, Object> extensions;
 
-    public ExceptionWhileDataFetching(ResultPath path, Throwable exception, SourceLocation sourceLocation) {
+    public ExceptionWhileDataFetching(ResultPath path, Throwable exception, @Nullable SourceLocation sourceLocation) {
         this.path = assertNotNull(path).toList();
         this.exception = assertNotNull(exception);
         this.locations = Collections.singletonList(sourceLocation);
diff --git a/src/main/java/graphql/GraphQL.java b/src/main/java/graphql/GraphQL.java
index 1441238b89..d25f596175 100644
--- a/src/main/java/graphql/GraphQL.java
+++ b/src/main/java/graphql/GraphQL.java
@@ -23,9 +23,12 @@
 import graphql.execution.preparsed.NoOpPreparsedDocumentProvider;
 import graphql.execution.preparsed.PreparsedDocumentEntry;
 import graphql.execution.preparsed.PreparsedDocumentProvider;
+import graphql.introspection.GoodFaithIntrospection;
 import graphql.language.Document;
 import graphql.schema.GraphQLSchema;
+import graphql.validation.GoodFaithIntrospectionExceeded;
 import graphql.validation.OperationValidationRule;
+import graphql.validation.QueryComplexityLimits;
 import graphql.validation.ValidationError;
 import org.jspecify.annotations.NullMarked;
 import org.jspecify.annotations.NullUnmarked;
@@ -547,7 +550,7 @@ private CompletableFuture<ExecutionResult> parseValidateAndExecute(ExecutionInpu
                 return CompletableFuture.completedFuture(new ExecutionResultImpl(preparsedDocumentEntry.getErrors()));
             }
             try {
-                return execute(Assert.assertNotNull(executionInputRef.get()), preparsedDocumentEntry.getDocument(), graphQLSchema, instrumentationState, engineRunningState, profiler);
+                return execute(Assert.assertNotNull(executionInputRef.get()), assertNotNull(preparsedDocumentEntry.getDocument(), "document must not be null"), graphQLSchema, instrumentationState, engineRunningState, profiler);
             } catch (AbortExecutionException e) {
                 return CompletableFuture.completedFuture(e.toExecutionResult());
             }
@@ -562,12 +565,17 @@ private PreparsedDocumentEntry parseAndValidate(AtomicReference<ExecutionInput>
         if (parseResult.isFailure()) {
             return new PreparsedDocumentEntry(assertNotNull(parseResult.getSyntaxException(), "Parse result syntax exception cannot be null when failed").toInvalidSyntaxError());
         } else {
-            final Document document = parseResult.getDocument();
+            final Document document = assertNotNull(parseResult.getDocument(), "Document cannot be null when parse succeeded");
             // they may have changed the document and the variables via instrumentation so update the reference to it
             executionInput = executionInput.transform(builder -> builder.variables(parseResult.getVariables()));
             executionInputRef.set(executionInput);
 
-            final List<ValidationError> errors = validate(executionInput, assertNotNull(document, "Document cannot be null when parse succeeded"), graphQLSchema, instrumentationState);
+            final List<ValidationError> errors;
+            try {
+                errors = validate(executionInput, document, graphQLSchema, instrumentationState);
+            } catch (GoodFaithIntrospectionExceeded e) {
+                return new PreparsedDocumentEntry(document, List.of(e.toBadFaithError()));
+            }
             if (!errors.isEmpty()) {
                 return new PreparsedDocumentEntry(document, errors);
             }
@@ -601,7 +609,15 @@ private List<ValidationError> validate(ExecutionInput executionInput, Document d
 
         Predicate<OperationValidationRule> validationRulePredicate = executionInput.getGraphQLContext().getOrDefault(ParseAndValidate.INTERNAL_VALIDATION_PREDICATE_HINT, r -> true);
         Locale locale = executionInput.getLocale();
-        List<ValidationError> validationErrors = ParseAndValidate.validate(graphQLSchema, document, validationRulePredicate, locale);
+        QueryComplexityLimits limits = executionInput.getGraphQLContext().get(QueryComplexityLimits.KEY);
+
+        // Good Faith Introspection: disable the rule if good faith is off
+        if (!GoodFaithIntrospection.isEnabled(executionInput.getGraphQLContext())) {
+            Predicate<OperationValidationRule> existing = validationRulePredicate;
+            validationRulePredicate = rule -> rule != OperationValidationRule.GOOD_FAITH_INTROSPECTION && existing.test(rule);
+        }
+
+        List<ValidationError> validationErrors = ParseAndValidate.validate(graphQLSchema, document, validationRulePredicate, locale, limits);
 
         validationCtx.onCompleted(validationErrors, null);
         return validationErrors;
diff --git a/src/main/java/graphql/ParseAndValidate.java b/src/main/java/graphql/ParseAndValidate.java
index 12af6af3a8..a092f28fc0 100644
--- a/src/main/java/graphql/ParseAndValidate.java
+++ b/src/main/java/graphql/ParseAndValidate.java
@@ -7,10 +7,12 @@
 import graphql.parser.ParserOptions;
 import graphql.schema.GraphQLSchema;
 import graphql.validation.OperationValidationRule;
+import graphql.validation.QueryComplexityLimits;
 import graphql.validation.ValidationError;
 import graphql.validation.Validator;
 import org.jspecify.annotations.NonNull;
 import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.List;
 import java.util.Locale;
@@ -118,8 +120,23 @@ public static List<ValidationError> validate(@NonNull GraphQLSchema graphQLSchem
      * @return a result object that indicates how this operation went
      */
     public static List<ValidationError> validate(@NonNull GraphQLSchema graphQLSchema, @NonNull Document parsedDocument, @NonNull Predicate<OperationValidationRule> rulePredicate, @NonNull Locale locale) {
+        return validate(graphQLSchema, parsedDocument, rulePredicate, locale, null);
+    }
+
+    /**
+     * This can be called to validate a parsed graphql query.
+     *
+     * @param graphQLSchema  the graphql schema to validate against
+     * @param parsedDocument the previously parsed document
+     * @param rulePredicate  this predicate is used to decide what validation rules will be applied
+     * @param locale         the current locale
+     * @param limits         optional query complexity limits to enforce
+     *
+     * @return a result object that indicates how this operation went
+     */
+    public static List<ValidationError> validate(GraphQLSchema graphQLSchema, Document parsedDocument, Predicate<OperationValidationRule> rulePredicate, Locale locale, @Nullable QueryComplexityLimits limits) {
         Validator validator = new Validator();
-        return validator.validateDocument(graphQLSchema, parsedDocument, rulePredicate, locale);
+        return validator.validateDocument(graphQLSchema, parsedDocument, rulePredicate, locale, limits);
     }
 
     /**
diff --git a/src/main/java/graphql/UnresolvedTypeError.java b/src/main/java/graphql/UnresolvedTypeError.java
index ba9bf333a5..60200df158 100644
--- a/src/main/java/graphql/UnresolvedTypeError.java
+++ b/src/main/java/graphql/UnresolvedTypeError.java
@@ -32,8 +32,8 @@ private String mkMessage(ResultPath path, UnresolvedTypeException exception, Exe
         return format("Can't resolve '%s'. Abstract type '%s' must resolve to an Object type at runtime for field '%s.%s'. %s",
                 path,
                 exception.getInterfaceOrUnionType().getName(),
-                simplePrint(info.getParent().getUnwrappedNonNullType()),
-                info.getFieldDefinition().getName(),
+                simplePrint(assertNotNull(info.getParent(), "executionStepInfo parent must not be null").getUnwrappedNonNullType()),
+                assertNotNull(info.getFieldDefinition(), "fieldDefinition must not be null").getName(),
                 exception.getMessage());
     }
 
diff --git a/src/main/java/graphql/VisibleForTesting.java b/src/main/java/graphql/VisibleForTesting.java
index 864fa70d1c..e8097a97aa 100644
--- a/src/main/java/graphql/VisibleForTesting.java
+++ b/src/main/java/graphql/VisibleForTesting.java
@@ -7,12 +7,13 @@
 import static java.lang.annotation.ElementType.CONSTRUCTOR;
 import static java.lang.annotation.ElementType.FIELD;
 import static java.lang.annotation.ElementType.METHOD;
+import static java.lang.annotation.ElementType.TYPE;
 
 /**
- * Marks fields, methods etc as more visible than actually needed for testing purposes.
+ * Marks fields, methods, types etc as more visible than actually needed for testing purposes.
  */
 @Retention(RetentionPolicy.RUNTIME)
-@Target(value = {CONSTRUCTOR, METHOD, FIELD})
+@Target(value = {CONSTRUCTOR, METHOD, FIELD, TYPE})
 @Internal
 public @interface VisibleForTesting {
 }
diff --git a/src/main/java/graphql/analysis/MaxQueryComplexityInstrumentation.java b/src/main/java/graphql/analysis/MaxQueryComplexityInstrumentation.java
index 3a9f94f166..669f147aa3 100644
--- a/src/main/java/graphql/analysis/MaxQueryComplexityInstrumentation.java
+++ b/src/main/java/graphql/analysis/MaxQueryComplexityInstrumentation.java
@@ -26,7 +26,7 @@
  * Prevents execution if the query complexity is greater than the specified maxComplexity.
  * <p>
  * Use the {@code Function<QueryComplexityInfo, Boolean>} parameter to supply a function to perform a custom action when the max complexity
- * is exceeded. If the function returns {@code true} a {@link AbortExecutionException} is thrown.
+ * is exceeded. If the function returns {@code true} an {@link AbortExecutionException} is thrown.
  */
 @PublicApi
 @NullMarked
diff --git a/src/main/java/graphql/analysis/MaxQueryDepthInstrumentation.java b/src/main/java/graphql/analysis/MaxQueryDepthInstrumentation.java
index 1ac22227f8..6bab51da1a 100644
--- a/src/main/java/graphql/analysis/MaxQueryDepthInstrumentation.java
+++ b/src/main/java/graphql/analysis/MaxQueryDepthInstrumentation.java
@@ -9,6 +9,7 @@
 import graphql.execution.instrumentation.SimplePerformantInstrumentation;
 import graphql.execution.instrumentation.parameters.InstrumentationExecuteOperationParameters;
 import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.function.Function;
 
@@ -84,7 +85,7 @@ QueryTraverser newQueryTraverser(ExecutionContext executionContext) {
                 .build();
     }
 
-    private int getPathLength(QueryVisitorFieldEnvironment path) {
+    private int getPathLength(@Nullable QueryVisitorFieldEnvironment path) {
         int length = 1;
         while (path != null) {
             path = path.getParentEnvironment();
diff --git a/src/main/java/graphql/analysis/QueryComplexityCalculator.java b/src/main/java/graphql/analysis/QueryComplexityCalculator.java
index e16035cc7a..0ec297523d 100644
--- a/src/main/java/graphql/analysis/QueryComplexityCalculator.java
+++ b/src/main/java/graphql/analysis/QueryComplexityCalculator.java
@@ -4,6 +4,9 @@
 import graphql.execution.CoercedVariables;
 import graphql.language.Document;
 import graphql.schema.GraphQLSchema;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.LinkedHashMap;
 import java.util.Map;
@@ -16,12 +19,13 @@
  * into it.
  */
 @PublicApi
+@NullMarked
 public class QueryComplexityCalculator {
 
     private final FieldComplexityCalculator fieldComplexityCalculator;
     private final GraphQLSchema schema;
     private final Document document;
-    private final String operationName;
+    private final @Nullable String operationName;
     private final CoercedVariables variables;
 
     public QueryComplexityCalculator(Builder builder) {
@@ -95,6 +99,7 @@ public static Builder newCalculator() {
         return new Builder();
     }
 
+    @NullUnmarked
     public static class Builder {
         private FieldComplexityCalculator fieldComplexityCalculator;
         private GraphQLSchema schema;
diff --git a/src/main/java/graphql/analysis/QueryComplexityInfo.java b/src/main/java/graphql/analysis/QueryComplexityInfo.java
index 29914e960a..83e9002050 100644
--- a/src/main/java/graphql/analysis/QueryComplexityInfo.java
+++ b/src/main/java/graphql/analysis/QueryComplexityInfo.java
@@ -3,17 +3,20 @@
 import graphql.PublicApi;
 import graphql.execution.instrumentation.parameters.InstrumentationExecuteOperationParameters;
 import graphql.execution.instrumentation.parameters.InstrumentationValidationParameters;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 import org.jspecify.annotations.NullUnmarked;
 
 /**
  * The query complexity info.
  */
 @PublicApi
+@NullMarked
 public class QueryComplexityInfo {
 
     private final int complexity;
-    private final InstrumentationValidationParameters instrumentationValidationParameters;
-    private final InstrumentationExecuteOperationParameters instrumentationExecuteOperationParameters;
+    private final @Nullable InstrumentationValidationParameters instrumentationValidationParameters;
+    private final @Nullable InstrumentationExecuteOperationParameters instrumentationExecuteOperationParameters;
 
     private QueryComplexityInfo(Builder builder) {
         this.complexity = builder.complexity;
@@ -35,7 +38,7 @@ public int getComplexity() {
      *
      * @return the instrumentation validation parameters.
      */
-    public InstrumentationValidationParameters getInstrumentationValidationParameters() {
+    public @Nullable InstrumentationValidationParameters getInstrumentationValidationParameters() {
         return instrumentationValidationParameters;
     }
 
@@ -44,7 +47,7 @@ public InstrumentationValidationParameters getInstrumentationValidationParameter
      *
      * @return the instrumentation execute operation parameters.
      */
-    public InstrumentationExecuteOperationParameters getInstrumentationExecuteOperationParameters() {
+    public @Nullable InstrumentationExecuteOperationParameters getInstrumentationExecuteOperationParameters() {
         return instrumentationExecuteOperationParameters;
     }
 
diff --git a/src/main/java/graphql/analysis/QueryDepthInfo.java b/src/main/java/graphql/analysis/QueryDepthInfo.java
index a8d4a0ac03..329c2dd49c 100644
--- a/src/main/java/graphql/analysis/QueryDepthInfo.java
+++ b/src/main/java/graphql/analysis/QueryDepthInfo.java
@@ -1,12 +1,14 @@
 package graphql.analysis;
 
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
 import org.jspecify.annotations.NullUnmarked;
 
 /**
  * The query depth info.
  */
 @PublicApi
+@NullMarked
 public class QueryDepthInfo {
 
     private final int depth;
diff --git a/src/main/java/graphql/analysis/QueryReducer.java b/src/main/java/graphql/analysis/QueryReducer.java
index f19ee7fd93..e62aee4151 100644
--- a/src/main/java/graphql/analysis/QueryReducer.java
+++ b/src/main/java/graphql/analysis/QueryReducer.java
@@ -1,6 +1,7 @@
 package graphql.analysis;
 
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
 
 /**
  * Used by {@link QueryTraverser} to reduce the fields of a Document (or part of it) to a single value.
@@ -10,6 +11,7 @@
  * See {@link QueryTraverser#reducePostOrder(QueryReducer, Object)} and {@link QueryTraverser#reducePreOrder(QueryReducer, Object)}
  */
 @PublicApi
+@NullMarked
 @FunctionalInterface
 public interface QueryReducer<T> {
 
diff --git a/src/main/java/graphql/analysis/QueryTransformer.java b/src/main/java/graphql/analysis/QueryTransformer.java
index fbf5052a91..b1a8b63c20 100644
--- a/src/main/java/graphql/analysis/QueryTransformer.java
+++ b/src/main/java/graphql/analysis/QueryTransformer.java
@@ -13,6 +13,7 @@
 
 import java.util.LinkedHashMap;
 import java.util.Map;
+import org.jspecify.annotations.NullMarked;
 import org.jspecify.annotations.NullUnmarked;
 
 import static graphql.Assert.assertNotNull;
@@ -31,6 +32,7 @@
  * visitField calls.
  */
 @PublicApi
+@NullMarked
 public class QueryTransformer {
 
     private final Node root;
diff --git a/src/main/java/graphql/analysis/QueryTraversalOptions.java b/src/main/java/graphql/analysis/QueryTraversalOptions.java
index 7ce73f05ce..6c4a798da8 100644
--- a/src/main/java/graphql/analysis/QueryTraversalOptions.java
+++ b/src/main/java/graphql/analysis/QueryTraversalOptions.java
@@ -1,11 +1,13 @@
 package graphql.analysis;
 
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
 
 /**
  * This options object controls how {@link QueryTraverser} works
  */
 @PublicApi
+@NullMarked
 public class QueryTraversalOptions {
 
     private final boolean coerceFieldArguments;
diff --git a/src/main/java/graphql/analysis/QueryVisitor.java b/src/main/java/graphql/analysis/QueryVisitor.java
index 69d86f2449..262c591619 100644
--- a/src/main/java/graphql/analysis/QueryVisitor.java
+++ b/src/main/java/graphql/analysis/QueryVisitor.java
@@ -2,6 +2,7 @@
 
 import graphql.PublicApi;
 import graphql.util.TraversalControl;
+import org.jspecify.annotations.NullMarked;
 
 /**
  * Used by {@link QueryTraverser} to visit the nodes of a Query.
@@ -9,6 +10,7 @@
  * How this happens in detail (pre vs post-order for example) is defined by {@link QueryTraverser}.
  */
 @PublicApi
+@NullMarked
 public interface QueryVisitor {
 
     void visitField(QueryVisitorFieldEnvironment queryVisitorFieldEnvironment);
diff --git a/src/main/java/graphql/analysis/QueryVisitorFieldArgumentEnvironment.java b/src/main/java/graphql/analysis/QueryVisitorFieldArgumentEnvironment.java
index adf31abe42..42037553a1 100644
--- a/src/main/java/graphql/analysis/QueryVisitorFieldArgumentEnvironment.java
+++ b/src/main/java/graphql/analysis/QueryVisitorFieldArgumentEnvironment.java
@@ -7,10 +7,13 @@
 import graphql.schema.GraphQLFieldDefinition;
 import graphql.schema.GraphQLSchema;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.Map;
 
 @PublicApi
+@NullMarked
 public interface QueryVisitorFieldArgumentEnvironment {
 
     GraphQLSchema getSchema();
@@ -21,7 +24,7 @@ public interface QueryVisitorFieldArgumentEnvironment {
 
     Argument getArgument();
 
-    Object getArgumentValue();
+    @Nullable Object getArgumentValue();
 
     Map<String, Object> getVariables();
 
diff --git a/src/main/java/graphql/analysis/QueryVisitorFieldArgumentInputValue.java b/src/main/java/graphql/analysis/QueryVisitorFieldArgumentInputValue.java
index 106e596ae0..01288c095d 100644
--- a/src/main/java/graphql/analysis/QueryVisitorFieldArgumentInputValue.java
+++ b/src/main/java/graphql/analysis/QueryVisitorFieldArgumentInputValue.java
@@ -4,6 +4,8 @@
 import graphql.language.Value;
 import graphql.schema.GraphQLInputType;
 import graphql.schema.GraphQLInputValueDefinition;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 /**
  * This describes the tree structure that forms from a argument input type,
@@ -11,9 +13,10 @@
  * types and hence form a tree of values.
  */
 @PublicApi
+@NullMarked
 public interface QueryVisitorFieldArgumentInputValue {
 
-    QueryVisitorFieldArgumentInputValue getParent();
+    @Nullable QueryVisitorFieldArgumentInputValue getParent();
 
     GraphQLInputValueDefinition getInputValueDefinition();
 
@@ -21,5 +24,5 @@ public interface QueryVisitorFieldArgumentInputValue {
 
     GraphQLInputType getInputType();
 
-    Value getValue();
+    @Nullable Value<?> getValue();
 }
diff --git a/src/main/java/graphql/analysis/QueryVisitorFieldArgumentValueEnvironment.java b/src/main/java/graphql/analysis/QueryVisitorFieldArgumentValueEnvironment.java
index 5da2d02e8a..cf07dd1d50 100644
--- a/src/main/java/graphql/analysis/QueryVisitorFieldArgumentValueEnvironment.java
+++ b/src/main/java/graphql/analysis/QueryVisitorFieldArgumentValueEnvironment.java
@@ -6,10 +6,12 @@
 import graphql.schema.GraphQLFieldDefinition;
 import graphql.schema.GraphQLSchema;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
 
 import java.util.Map;
 
 @PublicApi
+@NullMarked
 public interface QueryVisitorFieldArgumentValueEnvironment {
 
     GraphQLSchema getSchema();
diff --git a/src/main/java/graphql/analysis/QueryVisitorFieldEnvironment.java b/src/main/java/graphql/analysis/QueryVisitorFieldEnvironment.java
index 608c5205df..4e98b8794d 100644
--- a/src/main/java/graphql/analysis/QueryVisitorFieldEnvironment.java
+++ b/src/main/java/graphql/analysis/QueryVisitorFieldEnvironment.java
@@ -9,10 +9,13 @@
 import graphql.schema.GraphQLOutputType;
 import graphql.schema.GraphQLSchema;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.Map;
 
 @PublicApi
+@NullMarked
 public interface QueryVisitorFieldEnvironment {
 
     /**
@@ -46,11 +49,11 @@ public interface QueryVisitorFieldEnvironment {
      */
     GraphQLFieldsContainer getFieldsContainer();
 
-    QueryVisitorFieldEnvironment getParentEnvironment();
+    @Nullable QueryVisitorFieldEnvironment getParentEnvironment();
 
     Map<String, Object> getArguments();
 
-    SelectionSetContainer getSelectionSetContainer();
+    @Nullable SelectionSetContainer<?> getSelectionSetContainer();
 
     TraverserContext<Node> getTraverserContext();
 }
diff --git a/src/main/java/graphql/analysis/QueryVisitorFragmentDefinitionEnvironment.java b/src/main/java/graphql/analysis/QueryVisitorFragmentDefinitionEnvironment.java
index da9ab15600..cf7a20af86 100644
--- a/src/main/java/graphql/analysis/QueryVisitorFragmentDefinitionEnvironment.java
+++ b/src/main/java/graphql/analysis/QueryVisitorFragmentDefinitionEnvironment.java
@@ -5,8 +5,10 @@
 import graphql.language.Node;
 import graphql.schema.GraphQLSchema;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
 
 @PublicApi
+@NullMarked
 public interface QueryVisitorFragmentDefinitionEnvironment {
 
     /**
diff --git a/src/main/java/graphql/analysis/QueryVisitorFragmentSpreadEnvironment.java b/src/main/java/graphql/analysis/QueryVisitorFragmentSpreadEnvironment.java
index 4d70f24753..d4318a392a 100644
--- a/src/main/java/graphql/analysis/QueryVisitorFragmentSpreadEnvironment.java
+++ b/src/main/java/graphql/analysis/QueryVisitorFragmentSpreadEnvironment.java
@@ -6,8 +6,10 @@
 import graphql.language.Node;
 import graphql.schema.GraphQLSchema;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
 
 @PublicApi
+@NullMarked
 public interface QueryVisitorFragmentSpreadEnvironment {
 
     /**
diff --git a/src/main/java/graphql/analysis/QueryVisitorInlineFragmentEnvironment.java b/src/main/java/graphql/analysis/QueryVisitorInlineFragmentEnvironment.java
index 699b5b453a..2295b635e2 100644
--- a/src/main/java/graphql/analysis/QueryVisitorInlineFragmentEnvironment.java
+++ b/src/main/java/graphql/analysis/QueryVisitorInlineFragmentEnvironment.java
@@ -5,8 +5,10 @@
 import graphql.language.Node;
 import graphql.schema.GraphQLSchema;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
 
 @PublicApi
+@NullMarked
 public interface QueryVisitorInlineFragmentEnvironment {
 
     /**
diff --git a/src/main/java/graphql/analysis/QueryVisitorStub.java b/src/main/java/graphql/analysis/QueryVisitorStub.java
index 72129f296e..0180e635ea 100644
--- a/src/main/java/graphql/analysis/QueryVisitorStub.java
+++ b/src/main/java/graphql/analysis/QueryVisitorStub.java
@@ -1,8 +1,10 @@
 package graphql.analysis;
 
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
 
 @PublicApi
+@NullMarked
 public class QueryVisitorStub implements QueryVisitor {
 
 
diff --git a/src/main/java/graphql/analysis/values/ValueTraverser.java b/src/main/java/graphql/analysis/values/ValueTraverser.java
index 664cda26be..0cc1c3d31b 100644
--- a/src/main/java/graphql/analysis/values/ValueTraverser.java
+++ b/src/main/java/graphql/analysis/values/ValueTraverser.java
@@ -19,11 +19,14 @@
 import graphql.schema.GraphQLNonNull;
 import graphql.schema.GraphQLScalarType;
 import graphql.schema.GraphQLTypeUtil;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 
+import static graphql.Assert.assertNotNull;
 import static graphql.Assert.assertShouldNeverHappen;
 import static graphql.Assert.assertTrue;
 import static graphql.analysis.values.ValueVisitor.ABSENCE_SENTINEL;
@@ -46,13 +49,14 @@
  * null values for non-nullable types say, so you need to be careful.
  */
 @PublicApi
+@NullMarked
 public class ValueTraverser {
 
     private static class InputElements implements ValueVisitor.InputElements {
 
         private final ImmutableList<GraphQLInputSchemaElement> inputElements;
         private final List<GraphQLInputSchemaElement> unwrappedInputElements;
-        private final GraphQLInputValueDefinition lastElement;
+        private final @Nullable GraphQLInputValueDefinition lastElement;
 
         private InputElements(GraphQLInputSchemaElement startElement) {
             this.inputElements = ImmutableList.of(startElement);
@@ -88,7 +92,7 @@ public List<GraphQLInputSchemaElement> getUnwrappedInputElements() {
         }
 
         @Override
-        public GraphQLInputValueDefinition getLastInputValueDefinition() {
+        public @Nullable GraphQLInputValueDefinition getLastInputValueDefinition() {
             return lastElement;
         }
     }
@@ -161,7 +165,7 @@ public static Map<String, Object> visitPreOrder(Map<String, Object> coercedArgum
      *
      * @return the same value if nothing changes or a new value if the visitor changes anything
      */
-    public static Object visitPreOrder(Object coercedArgumentValue, GraphQLArgument argument, ValueVisitor visitor) {
+    public static @Nullable Object visitPreOrder(@Nullable Object coercedArgumentValue, GraphQLArgument argument, ValueVisitor visitor) {
         InputElements inputElements = new InputElements(argument);
         Object newValue = visitor.visitArgumentValue(coercedArgumentValue, argument, inputElements);
         if (newValue == ABSENCE_SENTINEL) {
@@ -185,7 +189,7 @@ public static Object visitPreOrder(Object coercedArgumentValue, GraphQLArgument
      *
      * @return the same value if nothing changes or a new value if the visitor changes anything
      */
-    public static Object visitPreOrder(Object coercedArgumentValue, GraphQLAppliedDirectiveArgument argument, ValueVisitor visitor) {
+    public static @Nullable Object visitPreOrder(@Nullable Object coercedArgumentValue, GraphQLAppliedDirectiveArgument argument, ValueVisitor visitor) {
         InputElements inputElements = new InputElements(argument);
         Object newValue = visitor.visitAppliedDirectiveArgumentValue(coercedArgumentValue, argument, inputElements);
         if (newValue == ABSENCE_SENTINEL) {
@@ -198,7 +202,7 @@ public static Object visitPreOrder(Object coercedArgumentValue, GraphQLAppliedDi
         return newValue;
     }
 
-    private static Object visitPreOrderImpl(Object coercedValue, GraphQLInputType startingInputType, InputElements containingElements, ValueVisitor visitor) {
+    private static @Nullable Object visitPreOrderImpl(@Nullable Object coercedValue, GraphQLInputType startingInputType, InputElements containingElements, ValueVisitor visitor) {
         if (startingInputType instanceof GraphQLNonNull) {
             containingElements = containingElements.push(startingInputType);
         }
@@ -218,7 +222,7 @@ private static Object visitPreOrderImpl(Object coercedValue, GraphQLInputType st
         }
     }
 
-    private static Object visitObjectValue(Object coercedValue, GraphQLInputObjectType inputObjectType, InputElements containingElements, ValueVisitor visitor) {
+    private static @Nullable Object visitObjectValue(@Nullable Object coercedValue, GraphQLInputObjectType inputObjectType, InputElements containingElements, ValueVisitor visitor) {
         if (coercedValue != null) {
             assertTrue(coercedValue instanceof Map, "A input object type MUST have an Map<String,Object> value");
         }
@@ -263,7 +267,7 @@ private static Object visitObjectValue(Object coercedValue, GraphQLInputObjectTy
         }
     }
 
-    private static Object visitListValue(Object coercedValue, GraphQLList listInputType, InputElements containingElements, ValueVisitor visitor) {
+    private static @Nullable Object visitListValue(@Nullable Object coercedValue, GraphQLList listInputType, InputElements containingElements, ValueVisitor visitor) {
         if (coercedValue != null) {
             assertTrue(coercedValue instanceof List, "A list type MUST have an List value");
         }
@@ -281,7 +285,7 @@ private static Object visitListValue(Object coercedValue, GraphQLList listInputT
                 Object newValue = visitPreOrderImpl(subValue, inputType, containingElements, visitor);
                 if (copiedList != null) {
                     if (newValue != ABSENCE_SENTINEL) {
-                        copiedList.add(newValue);
+                        copiedList.add(assertNotNull(newValue, "list element must not be null"));
                     }
                 } else if (hasChanged(newValue, subValue)) {
                     // go into copy mode because something has changed
@@ -291,7 +295,7 @@ private static Object visitListValue(Object coercedValue, GraphQLList listInputT
                         copiedList.add(newList.get(j));
                     }
                     if (newValue != ABSENCE_SENTINEL) {
-                        copiedList.add(newValue);
+                        copiedList.add(assertNotNull(newValue, "list element must not be null"));
                     }
                 }
                 i++;
@@ -306,11 +310,11 @@ private static Object visitListValue(Object coercedValue, GraphQLList listInputT
         }
     }
 
-    private static boolean hasChanged(Object newValue, Object oldValue) {
+    private static boolean hasChanged(@Nullable Object newValue, @Nullable Object oldValue) {
         return newValue != oldValue || newValue == ABSENCE_SENTINEL;
     }
 
-    private static void setNewValue(Map<String, Object> newMap, String key, Object newValue) {
+    private static void setNewValue(Map<String, Object> newMap, String key, @Nullable Object newValue) {
         if (newValue == ABSENCE_SENTINEL) {
             newMap.remove(key);
         } else {
diff --git a/src/main/java/graphql/execution/AbortExecutionException.java b/src/main/java/graphql/execution/AbortExecutionException.java
index 950dfde9a0..fcbfd4612e 100644
--- a/src/main/java/graphql/execution/AbortExecutionException.java
+++ b/src/main/java/graphql/execution/AbortExecutionException.java
@@ -7,6 +7,8 @@
 import graphql.GraphQLException;
 import graphql.PublicApi;
 import graphql.language.SourceLocation;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -19,6 +21,7 @@
  * This Exception indicates that the current execution should be aborted.
  */
 @PublicApi
+@NullMarked
 public class AbortExecutionException extends GraphQLException implements GraphQLError {
 
     private final List<GraphQLError> underlyingErrors;
@@ -47,7 +50,7 @@ public AbortExecutionException(Throwable cause) {
     }
 
     @Override
-    public List<SourceLocation> getLocations() {
+    public @Nullable List<SourceLocation> getLocations() {
         return null;
     }
 
diff --git a/src/main/java/graphql/execution/AsyncExecutionStrategy.java b/src/main/java/graphql/execution/AsyncExecutionStrategy.java
index 8d1d430581..325a5829a8 100644
--- a/src/main/java/graphql/execution/AsyncExecutionStrategy.java
+++ b/src/main/java/graphql/execution/AsyncExecutionStrategy.java
@@ -3,6 +3,7 @@
 import graphql.ExecutionResult;
 import graphql.PublicApi;
 import graphql.execution.incremental.DeferredExecutionSupport;
+import org.jspecify.annotations.NullMarked;
 import graphql.execution.instrumentation.ExecutionStrategyInstrumentationContext;
 import graphql.execution.instrumentation.Instrumentation;
 import graphql.execution.instrumentation.parameters.InstrumentationExecutionStrategyParameters;
@@ -17,6 +18,7 @@
  * The standard graphql execution strategy that runs fields asynchronously non-blocking.
  */
 @PublicApi
+@NullMarked
 public class AsyncExecutionStrategy extends AbstractAsyncExecutionStrategy {
 
     /**
diff --git a/src/main/java/graphql/execution/AsyncSerialExecutionStrategy.java b/src/main/java/graphql/execution/AsyncSerialExecutionStrategy.java
index b5ff7cd5fa..6c865e05a0 100644
--- a/src/main/java/graphql/execution/AsyncSerialExecutionStrategy.java
+++ b/src/main/java/graphql/execution/AsyncSerialExecutionStrategy.java
@@ -4,6 +4,8 @@
 import graphql.ExecutionResult;
 import graphql.PublicApi;
 import graphql.execution.instrumentation.Instrumentation;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 import graphql.execution.instrumentation.InstrumentationContext;
 import graphql.execution.instrumentation.parameters.InstrumentationExecutionStrategyParameters;
 import graphql.introspection.Introspection;
@@ -12,6 +14,7 @@
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 
+import static graphql.Assert.assertNotNull;
 import static graphql.execution.instrumentation.SimpleInstrumentationContext.nonNullCtx;
 
 /**
@@ -19,6 +22,7 @@
  * See {@link AsyncExecutionStrategy} for a non-serial (parallel) execution of every field.
  */
 @PublicApi
+@NullMarked
 public class AsyncSerialExecutionStrategy extends AbstractAsyncExecutionStrategy {
 
     public AsyncSerialExecutionStrategy() {
@@ -50,7 +54,7 @@ public CompletableFuture<ExecutionResult> execute(ExecutionContext executionCont
         }
 
         CompletableFuture<List<Object>> resultsFuture = Async.eachSequentially(fieldNames, (fieldName, prevResults) -> {
-            MergedField currentField = fields.getSubField(fieldName);
+            MergedField currentField = assertNotNull(fields.getSubField(fieldName), "currentField must not be null");
             ResultPath fieldPath = parameters.getPath().segment(mkNameForPath(currentField));
             ExecutionStrategyParameters newParameters = parameters.transform(currentField, fieldPath);
 
@@ -65,7 +69,7 @@ public CompletableFuture<ExecutionResult> execute(ExecutionContext executionCont
         return overallResult;
     }
 
-    private Object resolveSerialField(ExecutionContext executionContext,
+    private @Nullable Object resolveSerialField(ExecutionContext executionContext,
                                       DataLoaderDispatchStrategy dataLoaderDispatcherStrategy,
                                       ExecutionStrategyParameters newParameters) {
         dataLoaderDispatcherStrategy.executionSerialStrategy(executionContext, newParameters);
diff --git a/src/main/java/graphql/execution/CoercedVariables.java b/src/main/java/graphql/execution/CoercedVariables.java
index 6123aeec82..b567b017e9 100644
--- a/src/main/java/graphql/execution/CoercedVariables.java
+++ b/src/main/java/graphql/execution/CoercedVariables.java
@@ -3,6 +3,8 @@
 import graphql.PublicApi;
 import graphql.collect.ImmutableKit;
 import graphql.collect.ImmutableMapWithNullValues;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.Map;
 
@@ -10,6 +12,7 @@
  * Holds coerced variables, that is their values are now in a canonical form.
  */
 @PublicApi
+@NullMarked
 public class CoercedVariables {
     private static final CoercedVariables EMPTY = CoercedVariables.of(ImmutableKit.emptyMap());
     private final ImmutableMapWithNullValues<String, Object> coercedVariables;
@@ -26,7 +29,7 @@ public boolean containsKey(String key) {
         return coercedVariables.containsKey(key);
     }
 
-    public Object get(String key) {
+    public @Nullable Object get(String key) {
         return coercedVariables.get(key);
     }
 
diff --git a/src/main/java/graphql/execution/DataFetcherExceptionHandlerParameters.java b/src/main/java/graphql/execution/DataFetcherExceptionHandlerParameters.java
index b17e3582b5..494f02cd56 100644
--- a/src/main/java/graphql/execution/DataFetcherExceptionHandlerParameters.java
+++ b/src/main/java/graphql/execution/DataFetcherExceptionHandlerParameters.java
@@ -4,6 +4,9 @@
 import graphql.language.SourceLocation;
 import graphql.schema.DataFetchingEnvironment;
 import graphql.schema.GraphQLFieldDefinition;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.Map;
 
@@ -11,6 +14,7 @@
  * The parameters available to {@link DataFetcherExceptionHandler}s
  */
 @PublicApi
+@NullMarked
 public class DataFetcherExceptionHandlerParameters {
 
     private final DataFetchingEnvironment dataFetchingEnvironment;
@@ -45,7 +49,7 @@ public Map<String, Object> getArgumentValues() {
         return dataFetchingEnvironment.getArguments();
     }
 
-    public SourceLocation getSourceLocation() {
+    public @Nullable SourceLocation getSourceLocation() {
         return getField().getSingleField().getSourceLocation();
     }
 
@@ -53,6 +57,7 @@ public static Builder newExceptionParameters() {
         return new Builder();
     }
 
+    @NullUnmarked
     public static class Builder {
         DataFetchingEnvironment dataFetchingEnvironment;
         Throwable exception;
diff --git a/src/main/java/graphql/execution/DataFetcherExceptionHandlerResult.java b/src/main/java/graphql/execution/DataFetcherExceptionHandlerResult.java
index 4059e91824..f05115e3ed 100644
--- a/src/main/java/graphql/execution/DataFetcherExceptionHandlerResult.java
+++ b/src/main/java/graphql/execution/DataFetcherExceptionHandlerResult.java
@@ -2,6 +2,8 @@
 
 import graphql.GraphQLError;
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -12,6 +14,7 @@
  * The result object for {@link graphql.execution.DataFetcherExceptionHandler}s
  */
 @PublicApi
+@NullMarked
 public class DataFetcherExceptionHandlerResult {
 
     private final List<GraphQLError> errors;
@@ -32,6 +35,7 @@ public static Builder newResult(GraphQLError error) {
         return new Builder().error(error);
     }
 
+    @NullUnmarked
     public static class Builder {
 
         private final List<GraphQLError> errors = new ArrayList<>();
diff --git a/src/main/java/graphql/execution/DefaultValueUnboxer.java b/src/main/java/graphql/execution/DefaultValueUnboxer.java
index db03d1cfad..b763ce11af 100644
--- a/src/main/java/graphql/execution/DefaultValueUnboxer.java
+++ b/src/main/java/graphql/execution/DefaultValueUnboxer.java
@@ -2,6 +2,8 @@
 
 import graphql.Internal;
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.Optional;
 import java.util.OptionalDouble;
@@ -12,16 +14,17 @@
  * Public API because it should be used as a delegate when implementing a custom {@link ValueUnboxer}
  */
 @PublicApi
+@NullMarked
 public class DefaultValueUnboxer implements ValueUnboxer {
 
 
     @Override
-    public Object unbox(final Object object) {
+    public @Nullable Object unbox(final Object object) {
         return unboxValue(object);
     }
 
     @Internal // used by next-gen at the moment
-    public static Object unboxValue(Object result) {
+    public static @Nullable Object unboxValue(Object result) {
         if (result instanceof Optional) {
             Optional optional = (Optional) result;
             return optional.orElse(null);
diff --git a/src/main/java/graphql/execution/Execution.java b/src/main/java/graphql/execution/Execution.java
index 38c82f5a53..448d1c7388 100644
--- a/src/main/java/graphql/execution/Execution.java
+++ b/src/main/java/graphql/execution/Execution.java
@@ -1,6 +1,7 @@
 package graphql.execution;
 
 
+import com.google.common.collect.ImmutableList;
 import graphql.Directives;
 import graphql.EngineRunningState;
 import graphql.ExecutionInput;
@@ -12,6 +13,8 @@
 import graphql.GraphQLException;
 import graphql.Internal;
 import graphql.Profiler;
+import graphql.execution.directives.OperationDirectivesResolver;
+import graphql.execution.directives.QueryAppliedDirective;
 import graphql.execution.incremental.IncrementalCallState;
 import graphql.execution.instrumentation.Instrumentation;
 import graphql.execution.instrumentation.InstrumentationContext;
@@ -40,6 +43,7 @@
 
 import java.util.Collections;
 import java.util.List;
+import java.util.Locale;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 import java.util.function.Supplier;
@@ -55,6 +59,7 @@
 @Internal
 public class Execution {
     private final FieldCollector fieldCollector = new FieldCollector();
+    private final OperationDirectivesResolver operationDirectivesResolver = new OperationDirectivesResolver();
     private final ExecutionStrategy queryStrategy;
     private final ExecutionStrategy mutationStrategy;
     private final ExecutionStrategy subscriptionStrategy;
@@ -100,9 +105,15 @@ public CompletableFuture<ExecutionResult> execute(Document document, GraphQLSche
 
         boolean propagateErrorsOnNonNullContractFailure = propagateErrorsOnNonNullContractFailure(getOperationResult.operationDefinition.getDirectives());
 
-        ResponseMapFactory responseMapFactory = GraphQL.unusualConfiguration(executionInput.getGraphQLContext())
+        GraphQLContext graphQLContext = executionInput.getGraphQLContext();
+        Locale locale = executionInput.getLocale();
+
+        ResponseMapFactory responseMapFactory = GraphQL.unusualConfiguration(graphQLContext)
                 .responseMapFactory().getOr(ResponseMapFactory.DEFAULT);
 
+        Supplier<Map<OperationDefinition, ImmutableList<QueryAppliedDirective>>> operationDirectives = FpKit.interThreadMemoize(() ->
+                operationDirectivesResolver.resolveDirectives(document, graphQLSchema, coercedVariables, graphQLContext, locale));
+
         ExecutionContext executionContext = newExecutionContextBuilder()
                 .instrumentation(instrumentation)
                 .instrumentationState(instrumentationState)
@@ -112,7 +123,7 @@ public CompletableFuture<ExecutionResult> execute(Document document, GraphQLSche
                 .mutationStrategy(mutationStrategy)
                 .subscriptionStrategy(subscriptionStrategy)
                 .context(executionInput.getContext())
-                .graphQLContext(executionInput.getGraphQLContext())
+                .graphQLContext(graphQLContext)
                 .localContext(executionInput.getLocalContext())
                 .root(executionInput.getRoot())
                 .fragmentsByName(getOperationResult.fragmentsByName)
@@ -120,8 +131,9 @@ public CompletableFuture<ExecutionResult> execute(Document document, GraphQLSche
                 .normalizedVariableValues(normalizedVariableValues)
                 .document(document)
                 .operationDefinition(getOperationResult.operationDefinition)
+                .operationDirectives(operationDirectives)
                 .dataLoaderRegistry(executionInput.getDataLoaderRegistry())
-                .locale(executionInput.getLocale())
+                .locale(locale)
                 .valueUnboxer(valueUnboxer)
                 .responseMapFactory(responseMapFactory)
                 .executionInput(executionInput)
diff --git a/src/main/java/graphql/execution/ExecutionContext.java b/src/main/java/graphql/execution/ExecutionContext.java
index ac4b1a8b0d..702d475209 100644
--- a/src/main/java/graphql/execution/ExecutionContext.java
+++ b/src/main/java/graphql/execution/ExecutionContext.java
@@ -11,6 +11,8 @@
 import graphql.Profiler;
 import graphql.PublicApi;
 import graphql.collect.ImmutableKit;
+import graphql.execution.directives.OperationDirectivesResolver;
+import graphql.execution.directives.QueryAppliedDirective;
 import graphql.execution.incremental.IncrementalCallState;
 import graphql.execution.instrumentation.Instrumentation;
 import graphql.execution.instrumentation.InstrumentationState;
@@ -18,11 +20,11 @@
 import graphql.language.FragmentDefinition;
 import graphql.language.OperationDefinition;
 import graphql.normalized.ExecutableNormalizedOperation;
-import graphql.normalized.ExecutableNormalizedOperationFactory;
 import graphql.schema.GraphQLSchema;
 import graphql.util.FpKit;
 import graphql.util.LockKit;
 import org.dataloader.DataLoaderRegistry;
+import org.jspecify.annotations.NullMarked;
 import org.jspecify.annotations.Nullable;
 
 import java.util.HashSet;
@@ -34,8 +36,13 @@
 import java.util.function.Consumer;
 import java.util.function.Supplier;
 
+import static graphql.Assert.assertNotNull;
+import static graphql.normalized.ExecutableNormalizedOperationFactory.Options;
+import static graphql.normalized.ExecutableNormalizedOperationFactory.createExecutableNormalizedOperation;
+
 @SuppressWarnings("TypeParameterUnusedInFormals")
 @PublicApi
+@NullMarked
 public class ExecutionContext {
 
     private final GraphQLSchema graphQLSchema;
@@ -73,6 +80,8 @@ public class ExecutionContext {
     private final ResultNodesInfo resultNodesInfo = new ResultNodesInfo();
     private final EngineRunningState engineRunningState;
 
+    private final Supplier<Map<OperationDefinition, ImmutableList<QueryAppliedDirective>>> allOperationsDirectives;
+    private final Supplier<Map<String, ImmutableList<QueryAppliedDirective>>> operationDirectives;
     private final Profiler profiler;
 
     ExecutionContext(ExecutionContextBuilder builder) {
@@ -99,10 +108,27 @@ public class ExecutionContext {
         this.localContext = builder.localContext;
         this.executionInput = builder.executionInput;
         this.dataLoaderDispatcherStrategy = builder.dataLoaderDispatcherStrategy;
-        this.queryTree = FpKit.interThreadMemoize(() -> ExecutableNormalizedOperationFactory.createExecutableNormalizedOperation(graphQLSchema, operationDefinition, fragmentsByName, coercedVariables));
         this.propagateErrorsOnNonNullContractFailure = builder.propagateErrorsOnNonNullContractFailure;
         this.engineRunningState = builder.engineRunningState;
         this.profiler = builder.profiler;
+        // lazy loading for performance
+        this.queryTree = mkExecutableNormalizedOperation();
+        this.allOperationsDirectives = builder.allOperationsDirectives;
+        this.operationDirectives = mkOpDirectives(builder.allOperationsDirectives);
+    }
+
+    private Supplier<ExecutableNormalizedOperation> mkExecutableNormalizedOperation() {
+        return FpKit.interThreadMemoize(() -> {
+            Options options = Options.defaultOptions().graphQLContext(graphQLContext).locale(locale);
+            return createExecutableNormalizedOperation(graphQLSchema, operationDefinition, fragmentsByName, coercedVariables, options);
+        });
+    }
+
+    private Supplier<Map<String, ImmutableList<QueryAppliedDirective>>> mkOpDirectives(Supplier<Map<OperationDefinition, ImmutableList<QueryAppliedDirective>>> allOperationsDirectives) {
+        return FpKit.interThreadMemoize(() -> {
+            List<QueryAppliedDirective> list = allOperationsDirectives.get().getOrDefault(operationDefinition, ImmutableList.of());
+            return OperationDirectivesResolver.toAppliedDirectivesByName(list);
+        });
     }
 
     public ExecutionId getExecutionId() {
@@ -137,6 +163,21 @@ public OperationDefinition getOperationDefinition() {
         return operationDefinition;
     }
 
+    /**
+     * @return the map of {@link QueryAppliedDirective}s by name that were on this executing operation
+     */
+    public Map<String, ImmutableList<QueryAppliedDirective>> getOperationDirectives() {
+        return operationDirectives.get();
+    }
+
+    /**
+     * @return the map of all the  {@link QueryAppliedDirective}s that were on the {@link Document} including
+     * {@link OperationDefinition}s that are not currently executing.
+     */
+    public Map<OperationDefinition, ImmutableList<QueryAppliedDirective>> getAllOperationDirectives() {
+        return allOperationsDirectives.get();
+    }
+
     public CoercedVariables getCoercedVariables() {
         return coercedVariables;
     }
@@ -156,7 +197,7 @@ public Supplier<NormalizedVariables> getNormalizedVariables() {
      * @deprecated use {@link #getGraphQLContext()} instead
      */
     @Deprecated(since = "2021-07-05")
-    @SuppressWarnings({ "unchecked", "TypeParameterUnusedInFormals" })
+    @SuppressWarnings({"unchecked", "TypeParameterUnusedInFormals"})
     public @Nullable <T> T getContext() {
         return (T) context;
     }
@@ -175,7 +216,7 @@ public <T> T getRoot() {
         return (T) root;
     }
 
-    public FragmentDefinition getFragment(String name) {
+    public @Nullable FragmentDefinition getFragment(String name) {
         return fragmentsByName.get(name);
     }
 
@@ -247,7 +288,7 @@ public void addError(GraphQLError error, ResultPath fieldPath) {
             if (!errorPaths.add(fieldPath)) {
                 return;
             }
-            this.errors.set(ImmutableKit.addToList(this.errors.get(), error));
+            this.errors.set(ImmutableKit.addToList(assertNotNull(this.errors.get(), "errors list must not be null"), error));
         });
     }
 
@@ -266,7 +307,7 @@ public void addError(GraphQLError error) {
                 ResultPath path = ResultPath.fromList(error.getPath());
                 this.errorPaths.add(path);
             }
-            this.errors.set(ImmutableKit.addToList(this.errors.get(), error));
+            this.errors.set(ImmutableKit.addToList(assertNotNull(this.errors.get(), "errors list must not be null"), error));
         });
     }
 
@@ -294,7 +335,7 @@ public void addErrors(List<GraphQLError> errors) {
                 }
             }
             this.errorPaths.addAll(newErrorPaths);
-            this.errors.set(ImmutableKit.concatLists(this.errors.get(), errors));
+            this.errors.set(ImmutableKit.concatLists(assertNotNull(this.errors.get(), "errors list must not be null"), errors));
         });
     }
 
@@ -307,7 +348,7 @@ public ResponseMapFactory getResponseMapFactory() {
      * @return the total list of errors for this execution context
      */
     public List<GraphQLError> getErrors() {
-        return errors.get();
+        return assertNotNull(errors.get(), "errors list must not be null");
     }
 
     public ExecutionStrategy getQueryStrategy() {
diff --git a/src/main/java/graphql/execution/ExecutionContextBuilder.java b/src/main/java/graphql/execution/ExecutionContextBuilder.java
index f8dd44898e..4077b8def3 100644
--- a/src/main/java/graphql/execution/ExecutionContextBuilder.java
+++ b/src/main/java/graphql/execution/ExecutionContextBuilder.java
@@ -10,6 +10,7 @@
 import graphql.Internal;
 import graphql.Profiler;
 import graphql.collect.ImmutableKit;
+import graphql.execution.directives.QueryAppliedDirective;
 import graphql.execution.instrumentation.Instrumentation;
 import graphql.execution.instrumentation.InstrumentationState;
 import graphql.language.Document;
@@ -19,6 +20,7 @@
 import org.dataloader.DataLoaderRegistry;
 import org.jspecify.annotations.Nullable;
 
+import java.util.Collections;
 import java.util.Locale;
 import java.util.Map;
 import java.util.function.Supplier;
@@ -55,6 +57,7 @@ public class ExecutionContextBuilder {
     EngineRunningState engineRunningState;
     ResponseMapFactory responseMapFactory = ResponseMapFactory.DEFAULT;
     Profiler profiler;
+    Supplier<Map<OperationDefinition, ImmutableList<QueryAppliedDirective>>> allOperationsDirectives = Collections::emptyMap;
 
     /**
      * @return a new builder of {@link graphql.execution.ExecutionContext}s
@@ -168,6 +171,7 @@ public ExecutionContextBuilder root(Object root) {
 
     /**
      * @param variables map of already coerced variables
+     *
      * @return this builder
      *
      * @deprecated use {@link #coercedVariables(CoercedVariables)} instead
@@ -246,13 +250,6 @@ public ExecutionContextBuilder propagapropagateErrorsOnNonNullContractFailureeEr
         return this;
     }
 
-
-    public ExecutionContext build() {
-        // preconditions
-        assertNotNull(executionId, "You must provide a query identifier");
-        return new ExecutionContext(this);
-    }
-
     public ExecutionContextBuilder engineRunningState(EngineRunningState engineRunningState) {
         this.engineRunningState = engineRunningState;
         return this;
@@ -262,4 +259,16 @@ public ExecutionContextBuilder profiler(Profiler profiler) {
         this.profiler = profiler;
         return this;
     }
+
+    public ExecutionContextBuilder operationDirectives(Supplier<Map<OperationDefinition, ImmutableList<QueryAppliedDirective>>> allOperationsDirectives) {
+        this.allOperationsDirectives = allOperationsDirectives;
+        return this;
+    }
+
+
+    public ExecutionContext build() {
+        // preconditions
+        assertNotNull(executionId, "You must provide a query identifier");
+        return new ExecutionContext(this);
+    }
 }
diff --git a/src/main/java/graphql/execution/ExecutionId.java b/src/main/java/graphql/execution/ExecutionId.java
index 40ffd3466f..4812c8edd7 100644
--- a/src/main/java/graphql/execution/ExecutionId.java
+++ b/src/main/java/graphql/execution/ExecutionId.java
@@ -3,11 +3,13 @@
 import graphql.Assert;
 import graphql.PublicApi;
 import graphql.util.IdGenerator;
+import org.jspecify.annotations.NullMarked;
 
 /**
  * This opaque identifier is used to identify a unique query execution
  */
 @PublicApi
+@NullMarked
 public class ExecutionId {
 
     /**
diff --git a/src/main/java/graphql/execution/ExecutionStepInfo.java b/src/main/java/graphql/execution/ExecutionStepInfo.java
index 26737cd127..0fecdfc491 100644
--- a/src/main/java/graphql/execution/ExecutionStepInfo.java
+++ b/src/main/java/graphql/execution/ExecutionStepInfo.java
@@ -9,6 +9,9 @@
 import graphql.schema.GraphQLObjectType;
 import graphql.schema.GraphQLOutputType;
 import graphql.schema.GraphQLTypeUtil;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.Map;
 import java.util.function.Consumer;
@@ -26,6 +29,7 @@
  * type instances, so this helper class adds this information during query execution.
  */
 @PublicApi
+@NullMarked
 public class ExecutionStepInfo {
 
     /*
@@ -56,16 +60,16 @@ public class ExecutionStepInfo {
      * A list element is characterized by having a path ending with an index segment. (ResultPath.isListSegment())
      */
     private final ResultPath path;
-    private final ExecutionStepInfo parent;
+    private final @Nullable ExecutionStepInfo parent;
 
     /**
      * field, fieldDefinition, fieldContainer and arguments differ per field StepInfo.
      * <p>
      * But for list StepInfos these properties are the same as the field returning the list.
      */
-    private final MergedField field;
-    private final GraphQLFieldDefinition fieldDefinition;
-    private final GraphQLObjectType fieldContainer;
+    private final @Nullable MergedField field;
+    private final @Nullable GraphQLFieldDefinition fieldDefinition;
+    private final @Nullable GraphQLObjectType fieldContainer;
     private final Supplier<ImmutableMapWithNullValues<String, Object>> arguments;
 
     private ExecutionStepInfo(Builder builder) {
@@ -83,10 +87,10 @@ private ExecutionStepInfo(Builder builder) {
      */
     private ExecutionStepInfo(GraphQLOutputType type,
                               ResultPath path,
-                              ExecutionStepInfo parent,
-                              MergedField field,
-                              GraphQLFieldDefinition fieldDefinition,
-                              GraphQLObjectType fieldContainer,
+                              @Nullable ExecutionStepInfo parent,
+                              @Nullable MergedField field,
+                              @Nullable GraphQLFieldDefinition fieldDefinition,
+                              @Nullable GraphQLObjectType fieldContainer,
                               Supplier<ImmutableMapWithNullValues<String, Object>> arguments) {
         this.type = assertNotNull(type, "you must provide a graphql type");
         this.path = path;
@@ -104,7 +108,7 @@ private ExecutionStepInfo(GraphQLOutputType type,
      *
      * @return the GraphQLObjectType defining the {@link #getFieldDefinition()}
      */
-    public GraphQLObjectType getObjectType() {
+    public @Nullable GraphQLObjectType getObjectType() {
         return fieldContainer;
     }
 
@@ -144,7 +148,7 @@ public <T extends GraphQLOutputType> T getUnwrappedNonNullTypeAs() {
      *
      * @return the field definition or null if there is not one
      */
-    public GraphQLFieldDefinition getFieldDefinition() {
+    public @Nullable GraphQLFieldDefinition getFieldDefinition() {
         return fieldDefinition;
     }
 
@@ -153,7 +157,7 @@ public GraphQLFieldDefinition getFieldDefinition() {
      *
      * @return the  merged fields
      */
-    public MergedField getField() {
+    public @Nullable MergedField getField() {
         return field;
     }
 
@@ -194,14 +198,14 @@ public Map<String, Object> getArguments() {
      * @return the named argument or null if it's not present
      */
     @SuppressWarnings("unchecked")
-    public <T> T getArgument(String name) {
+    public @Nullable <T> T getArgument(String name) {
         return (T) getArguments().get(name);
     }
 
     /**
      * @return the parent type information
      */
-    public ExecutionStepInfo getParent() {
+    public @Nullable ExecutionStepInfo getParent() {
         return parent;
     }
 
@@ -264,7 +268,7 @@ public ExecutionStepInfo transform(Consumer<Builder> builderConsumer) {
     }
 
     public String getResultKey() {
-        return field.getResultKey();
+        return assertNotNull(field, "field must not be null").getResultKey();
     }
 
     /**
@@ -278,6 +282,7 @@ public static ExecutionStepInfo.Builder newExecutionStepInfo(ExecutionStepInfo e
         return new Builder(existing);
     }
 
+    @NullUnmarked
     public static class Builder {
         GraphQLOutputType type;
         ExecutionStepInfo parentInfo;
diff --git a/src/main/java/graphql/execution/ExecutionStepInfoFactory.java b/src/main/java/graphql/execution/ExecutionStepInfoFactory.java
index 286106a7dc..fc382c2052 100644
--- a/src/main/java/graphql/execution/ExecutionStepInfoFactory.java
+++ b/src/main/java/graphql/execution/ExecutionStepInfoFactory.java
@@ -18,6 +18,7 @@
 import java.util.Map;
 import java.util.function.Supplier;
 
+import static graphql.Assert.assertNotNull;
 import static graphql.execution.ExecutionStepInfo.newExecutionStepInfo;
 
 @Internal
@@ -44,7 +45,7 @@ public ExecutionStepInfo createExecutionStepInfo(ExecutionContext executionConte
                                                         ExecutionStrategyParameters parameters,
                                                         GraphQLFieldDefinition fieldDefinition,
                                                         @Nullable GraphQLObjectType fieldContainer) {
-        MergedField field = parameters.getField();
+        MergedField field = assertNotNull(parameters.getField(), "field must not be null");
         ExecutionStepInfo parentStepInfo = parameters.getExecutionStepInfo();
         GraphQLOutputType fieldType = fieldDefinition.getType();
         List<GraphQLArgument> fieldArgDefs = fieldDefinition.getArguments();
diff --git a/src/main/java/graphql/execution/ExecutionStrategyParameters.java b/src/main/java/graphql/execution/ExecutionStrategyParameters.java
index 71d7fd9f8b..21b828b7d5 100644
--- a/src/main/java/graphql/execution/ExecutionStrategyParameters.java
+++ b/src/main/java/graphql/execution/ExecutionStrategyParameters.java
@@ -3,6 +3,8 @@
 import graphql.Internal;
 import graphql.PublicApi;
 import graphql.execution.incremental.AlternativeCallContext;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
 import org.jspecify.annotations.Nullable;
 
 import java.util.function.Consumer;
@@ -13,26 +15,27 @@
  * The parameters that are passed to execution strategies
  */
 @PublicApi
+@NullMarked
 public class ExecutionStrategyParameters {
     private final ExecutionStepInfo executionStepInfo;
-    private final Object source;
-    private final Object localContext;
+    private final @Nullable Object source;
+    private final @Nullable Object localContext;
     private final MergedSelectionSet fields;
     private final NonNullableFieldValidator nonNullableFieldValidator;
     private final ResultPath path;
-    private final MergedField currentField;
-    private final ExecutionStrategyParameters parent;
-    private final AlternativeCallContext alternativeCallContext;
+    private final @Nullable MergedField currentField;
+    private final @Nullable ExecutionStrategyParameters parent;
+    private final @Nullable AlternativeCallContext alternativeCallContext;
 
     private ExecutionStrategyParameters(ExecutionStepInfo executionStepInfo,
-                                        Object source,
-                                        Object localContext,
+                                        @Nullable Object source,
+                                        @Nullable Object localContext,
                                         MergedSelectionSet fields,
                                         NonNullableFieldValidator nonNullableFieldValidator,
                                         ResultPath path,
-                                        MergedField currentField,
-                                        ExecutionStrategyParameters parent,
-                                        AlternativeCallContext alternativeCallContext) {
+                                        @Nullable MergedField currentField,
+                                        @Nullable ExecutionStrategyParameters parent,
+                                        @Nullable AlternativeCallContext alternativeCallContext) {
 
         this.executionStepInfo = assertNotNull(executionStepInfo, "executionStepInfo is null");
         this.localContext = localContext;
@@ -49,7 +52,7 @@ public ExecutionStepInfo getExecutionStepInfo() {
         return executionStepInfo;
     }
 
-    public Object getSource() {
+    public @Nullable Object getSource() {
         return source;
     }
 
@@ -65,11 +68,11 @@ public ResultPath getPath() {
         return path;
     }
 
-    public Object getLocalContext() {
+    public @Nullable Object getLocalContext() {
         return localContext;
     }
 
-    public ExecutionStrategyParameters getParent() {
+    public @Nullable ExecutionStrategyParameters getParent() {
         return parent;
     }
 
@@ -113,7 +116,7 @@ public boolean isInDeferredContext() {
      *
      * @return the current merged fields
      */
-    public MergedField getField() {
+    public @Nullable MergedField getField() {
         return currentField;
     }
 
@@ -134,7 +137,7 @@ ExecutionStrategyParameters transform(MergedField currentField,
     @Internal
     ExecutionStrategyParameters transform(ExecutionStepInfo executionStepInfo,
                                           MergedSelectionSet fields,
-                                          Object source) {
+                                          @Nullable Object source) {
         return new ExecutionStrategyParameters(executionStepInfo,
                 source,
                 localContext,
@@ -149,8 +152,8 @@ ExecutionStrategyParameters transform(ExecutionStepInfo executionStepInfo,
     @Internal
     ExecutionStrategyParameters transform(ExecutionStepInfo executionStepInfo,
                                           ResultPath path,
-                                          Object localContext,
-                                          Object source) {
+                                          @Nullable Object localContext,
+                                          @Nullable Object source) {
         return new ExecutionStrategyParameters(executionStepInfo,
                 source,
                 localContext,
@@ -164,8 +167,8 @@ ExecutionStrategyParameters transform(ExecutionStepInfo executionStepInfo,
 
     @Internal
     ExecutionStrategyParameters transform(ExecutionStepInfo executionStepInfo,
-                                          Object localContext,
-                                          Object source) {
+                                          @Nullable Object localContext,
+                                          @Nullable Object source) {
         return new ExecutionStrategyParameters(executionStepInfo,
                 source,
                 localContext,
@@ -212,6 +215,7 @@ public static Builder newParameters(ExecutionStrategyParameters oldParameters) {
         return new Builder(oldParameters);
     }
 
+    @NullUnmarked
     public static class Builder {
         ExecutionStepInfo executionStepInfo;
         Object source;
diff --git a/src/main/java/graphql/execution/FetchedValue.java b/src/main/java/graphql/execution/FetchedValue.java
index fe56fa0a10..b4b5f03875 100644
--- a/src/main/java/graphql/execution/FetchedValue.java
+++ b/src/main/java/graphql/execution/FetchedValue.java
@@ -4,6 +4,8 @@
 import graphql.GraphQLError;
 import graphql.PublicApi;
 import graphql.execution.instrumentation.parameters.InstrumentationFieldCompleteParameters;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.List;
 
@@ -12,9 +14,10 @@
  * and therefore part of the public despite never used in a method signature.
  */
 @PublicApi
+@NullMarked
 public class FetchedValue {
-    private final Object fetchedValue;
-    private final Object localContext;
+    private final @Nullable Object fetchedValue;
+    private final @Nullable Object localContext;
     private final ImmutableList<GraphQLError> errors;
 
     /**
@@ -25,7 +28,7 @@ public class FetchedValue {
      *
      * @return the {@link FetchedValue#getFetchedValue()} if its wrapped otherwise the source value itself
      */
-    public static Object getFetchedValue(Object sourceValue) {
+    public static @Nullable Object getFetchedValue(@Nullable Object sourceValue) {
         if (sourceValue instanceof FetchedValue) {
             return ((FetchedValue) sourceValue).fetchedValue;
         } else {
@@ -42,7 +45,7 @@ public static Object getFetchedValue(Object sourceValue) {
      *
      * @return the {@link FetchedValue#getFetchedValue()} if its wrapped otherwise the default local context
      */
-    public static Object getLocalContext(Object sourceValue, Object defaultLocalContext) {
+    public static @Nullable Object getLocalContext(@Nullable Object sourceValue, @Nullable Object defaultLocalContext) {
         if (sourceValue instanceof FetchedValue) {
             return ((FetchedValue) sourceValue).localContext;
         } else {
@@ -50,7 +53,7 @@ public static Object getLocalContext(Object sourceValue, Object defaultLocalCont
         }
     }
 
-    public FetchedValue(Object fetchedValue, List<GraphQLError> errors, Object localContext) {
+    public FetchedValue(@Nullable Object fetchedValue, List<GraphQLError> errors, @Nullable Object localContext) {
         this.fetchedValue = fetchedValue;
         this.errors = ImmutableList.copyOf(errors);
         this.localContext = localContext;
@@ -59,7 +62,7 @@ public FetchedValue(Object fetchedValue, List<GraphQLError> errors, Object local
     /*
      * the unboxed value meaning not Optional, not DataFetcherResult etc
      */
-    public Object getFetchedValue() {
+    public @Nullable Object getFetchedValue() {
         return fetchedValue;
     }
 
@@ -67,7 +70,7 @@ public List<GraphQLError> getErrors() {
         return errors;
     }
 
-    public Object getLocalContext() {
+    public @Nullable Object getLocalContext() {
         return localContext;
     }
 
diff --git a/src/main/java/graphql/execution/FieldValueInfo.java b/src/main/java/graphql/execution/FieldValueInfo.java
index 2839a8cd5b..0108503bca 100644
--- a/src/main/java/graphql/execution/FieldValueInfo.java
+++ b/src/main/java/graphql/execution/FieldValueInfo.java
@@ -2,6 +2,8 @@
 
 import com.google.common.collect.ImmutableList;
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
@@ -19,6 +21,7 @@
  * values might need a call to a database or other systems will tend to be {@link CompletableFuture} promises.
  */
 @PublicApi
+@NullMarked
 public class FieldValueInfo {
 
     public enum CompleteValueType {
@@ -30,14 +33,14 @@ public enum CompleteValueType {
     }
 
     private final CompleteValueType completeValueType;
-    private final Object /* CompletableFuture<Object> | Object */ fieldValueObject;
+    private final @Nullable Object /* CompletableFuture<Object> | Object */ fieldValueObject;
     private final List<FieldValueInfo> fieldValueInfos;
 
-    public FieldValueInfo(CompleteValueType completeValueType, Object fieldValueObject) {
+    public FieldValueInfo(CompleteValueType completeValueType, @Nullable Object fieldValueObject) {
         this(completeValueType, fieldValueObject, ImmutableList.of());
     }
 
-    public FieldValueInfo(CompleteValueType completeValueType, Object fieldValueObject, List<FieldValueInfo> fieldValueInfos) {
+    public FieldValueInfo(CompleteValueType completeValueType, @Nullable Object fieldValueObject, List<FieldValueInfo> fieldValueInfos) {
         assertNotNull(fieldValueInfos, "fieldValueInfos can't be null");
         this.completeValueType = completeValueType;
         this.fieldValueObject = fieldValueObject;
@@ -58,7 +61,7 @@ public CompleteValueType getCompleteValueType() {
      *
      * @return either an object that is materialized or a {@link CompletableFuture} promise to a value
      */
-    public Object /* CompletableFuture<Object> | Object */ getFieldValueObject() {
+    public @Nullable Object /* CompletableFuture<Object> | Object */ getFieldValueObject() {
         return fieldValueObject;
     }
 
diff --git a/src/main/java/graphql/execution/InputMapDefinesTooManyFieldsException.java b/src/main/java/graphql/execution/InputMapDefinesTooManyFieldsException.java
index 654c069c34..e4aef7e2c1 100644
--- a/src/main/java/graphql/execution/InputMapDefinesTooManyFieldsException.java
+++ b/src/main/java/graphql/execution/InputMapDefinesTooManyFieldsException.java
@@ -7,6 +7,8 @@
 import graphql.language.SourceLocation;
 import graphql.schema.GraphQLType;
 import graphql.schema.GraphQLTypeUtil;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.List;
 
@@ -16,6 +18,7 @@
  * - This unordered map should not contain any entries with names not defined by a field of this input object type, otherwise an error should be thrown.
  */
 @PublicApi
+@NullMarked
 public class InputMapDefinesTooManyFieldsException extends GraphQLException implements GraphQLError {
 
     public InputMapDefinesTooManyFieldsException(GraphQLType graphQLType, String fieldName) {
@@ -23,7 +26,7 @@ public InputMapDefinesTooManyFieldsException(GraphQLType graphQLType, String fie
     }
 
     @Override
-    public List<SourceLocation> getLocations() {
+    public @Nullable List<SourceLocation> getLocations() {
         return null;
     }
 
diff --git a/src/main/java/graphql/execution/MergedSelectionSet.java b/src/main/java/graphql/execution/MergedSelectionSet.java
index 434b8da4f5..75b7df45ae 100644
--- a/src/main/java/graphql/execution/MergedSelectionSet.java
+++ b/src/main/java/graphql/execution/MergedSelectionSet.java
@@ -3,6 +3,9 @@
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableMap;
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.List;
 import java.util.Map;
@@ -10,6 +13,7 @@
 
 
 @PublicApi
+@NullMarked
 public class MergedSelectionSet {
 
     private final Map<String, MergedField> subFields;
@@ -36,7 +40,7 @@ public Set<String> keySet() {
         return subFields.keySet();
     }
 
-    public MergedField getSubField(String key) {
+    public @Nullable MergedField getSubField(String key) {
         return subFields.get(key);
     }
 
@@ -52,6 +56,7 @@ public static Builder newMergedSelectionSet() {
         return new Builder();
     }
 
+    @NullUnmarked
     public static class Builder {
 
         private Map<String, MergedField> subFields;
diff --git a/src/main/java/graphql/execution/MissingRootTypeException.java b/src/main/java/graphql/execution/MissingRootTypeException.java
index 9662f69ec0..7ae68cbb31 100644
--- a/src/main/java/graphql/execution/MissingRootTypeException.java
+++ b/src/main/java/graphql/execution/MissingRootTypeException.java
@@ -8,21 +8,24 @@
 import graphql.GraphQLException;
 import graphql.PublicApi;
 import graphql.language.SourceLocation;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 /**
  * This is thrown if a query is attempting to perform an operation not defined in the GraphQL schema
  */
 @PublicApi
+@NullMarked
 public class MissingRootTypeException extends GraphQLException implements GraphQLError {
-    private List<SourceLocation> sourceLocations;
+    private @Nullable List<SourceLocation> sourceLocations;
 
-    public MissingRootTypeException(String message, SourceLocation sourceLocation) {
+    public MissingRootTypeException(String message, @Nullable SourceLocation sourceLocation) {
         super(message);
         this.sourceLocations = sourceLocation == null ? null : Collections.singletonList(sourceLocation);
     }
 
     @Override
-    public List<SourceLocation> getLocations() {
+    public @Nullable List<SourceLocation> getLocations() {
         return sourceLocations;
     }
 
diff --git a/src/main/java/graphql/execution/NonNullableValueCoercedAsNullException.java b/src/main/java/graphql/execution/NonNullableValueCoercedAsNullException.java
index 4dfb680815..9192d50802 100644
--- a/src/main/java/graphql/execution/NonNullableValueCoercedAsNullException.java
+++ b/src/main/java/graphql/execution/NonNullableValueCoercedAsNullException.java
@@ -10,6 +10,8 @@
 import graphql.schema.GraphQLInputObjectField;
 import graphql.schema.GraphQLType;
 import graphql.schema.GraphQLTypeUtil;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.Collections;
 import java.util.List;
@@ -20,9 +22,10 @@
  * This is thrown if a non nullable value is coerced to a null value
  */
 @PublicApi
+@NullMarked
 public class NonNullableValueCoercedAsNullException extends GraphQLException implements GraphQLError {
-    private List<SourceLocation> sourceLocations;
-    private List<Object> path;
+    private @Nullable List<SourceLocation> sourceLocations;
+    private @Nullable List<Object> path;
 
     public NonNullableValueCoercedAsNullException(VariableDefinition variableDefinition, GraphQLType graphQLType) {
         super(format("Variable '%s' has coerced Null value for NonNull type '%s'",
@@ -74,12 +77,12 @@ public NonNullableValueCoercedAsNullException(GraphQLArgument graphQLArgument) {
     }
 
     @Override
-    public List<SourceLocation> getLocations() {
+    public @Nullable List<SourceLocation> getLocations() {
         return sourceLocations;
     }
 
     @Override
-    public List<Object> getPath() {
+    public @Nullable List<Object> getPath() {
         return path;
     }
 
diff --git a/src/main/java/graphql/execution/NormalizedVariables.java b/src/main/java/graphql/execution/NormalizedVariables.java
index ef16fec3cf..59b1d905b3 100644
--- a/src/main/java/graphql/execution/NormalizedVariables.java
+++ b/src/main/java/graphql/execution/NormalizedVariables.java
@@ -4,6 +4,8 @@
 import graphql.collect.ImmutableKit;
 import graphql.collect.ImmutableMapWithNullValues;
 import graphql.normalized.NormalizedInputValue;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.Map;
 
@@ -11,6 +13,7 @@
  * Holds coerced variables, that is their values are now in a normalized {@link graphql.normalized.NormalizedInputValue} form.
  */
 @PublicApi
+@NullMarked
 public class NormalizedVariables {
     private final ImmutableMapWithNullValues<String, NormalizedInputValue> normalisedVariables;
 
@@ -26,7 +29,7 @@ public boolean containsKey(String key) {
         return normalisedVariables.containsKey(key);
     }
 
-    public Object get(String key) {
+    public @Nullable Object get(String key) {
         return normalisedVariables.get(key);
     }
 
diff --git a/src/main/java/graphql/execution/OneOfNullValueException.java b/src/main/java/graphql/execution/OneOfNullValueException.java
index 40e5bbccae..cc9d3da824 100644
--- a/src/main/java/graphql/execution/OneOfNullValueException.java
+++ b/src/main/java/graphql/execution/OneOfNullValueException.java
@@ -5,6 +5,8 @@
 import graphql.GraphQLException;
 import graphql.PublicApi;
 import graphql.language.SourceLocation;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.List;
 
@@ -12,6 +14,7 @@
  * The input map to One Of Input Types MUST only have 1 entry with a non null value
  */
 @PublicApi
+@NullMarked
 public class OneOfNullValueException extends GraphQLException implements GraphQLError {
 
     public OneOfNullValueException(String message) {
@@ -19,7 +22,7 @@ public OneOfNullValueException(String message) {
     }
 
     @Override
-    public List<SourceLocation> getLocations() {
+    public @Nullable List<SourceLocation> getLocations() {
         return null;
     }
 
diff --git a/src/main/java/graphql/execution/OneOfTooManyKeysException.java b/src/main/java/graphql/execution/OneOfTooManyKeysException.java
index f8d3c0053a..50ff017b15 100644
--- a/src/main/java/graphql/execution/OneOfTooManyKeysException.java
+++ b/src/main/java/graphql/execution/OneOfTooManyKeysException.java
@@ -5,6 +5,8 @@
 import graphql.GraphQLException;
 import graphql.PublicApi;
 import graphql.language.SourceLocation;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.List;
 
@@ -12,6 +14,7 @@
  * The input map to One Of Input Types MUST only have 1 entry
  */
 @PublicApi
+@NullMarked
 public class OneOfTooManyKeysException extends GraphQLException implements GraphQLError {
 
     public OneOfTooManyKeysException(String message) {
@@ -19,7 +22,7 @@ public OneOfTooManyKeysException(String message) {
     }
 
     @Override
-    public List<SourceLocation> getLocations() {
+    public @Nullable List<SourceLocation> getLocations() {
         return null;
     }
 
diff --git a/src/main/java/graphql/execution/ResponseMapFactory.java b/src/main/java/graphql/execution/ResponseMapFactory.java
index 01a37d8491..2a7cd52bd1 100644
--- a/src/main/java/graphql/execution/ResponseMapFactory.java
+++ b/src/main/java/graphql/execution/ResponseMapFactory.java
@@ -2,6 +2,8 @@
 
 import graphql.ExperimentalApi;
 import graphql.PublicSpi;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.List;
 import java.util.Map;
@@ -12,6 +14,7 @@
  */
 @ExperimentalApi
 @PublicSpi
+@NullMarked
 public interface ResponseMapFactory {
 
     /**
@@ -27,6 +30,6 @@ public interface ResponseMapFactory {
      * @param values the values  like v1, v2, ..., vn
      * @return a new or reused map instance with (k1,v1), (k2, v2), ... (kn, vn)
      */
-    Map<String, Object> createInsertionOrdered(List<String> keys, List<Object> values);
+    Map<String, @Nullable Object> createInsertionOrdered(List<String> keys, List<@Nullable Object> values);
 
 }
diff --git a/src/main/java/graphql/execution/ResultNodesInfo.java b/src/main/java/graphql/execution/ResultNodesInfo.java
index afc366f6be..9e8b3cfec5 100644
--- a/src/main/java/graphql/execution/ResultNodesInfo.java
+++ b/src/main/java/graphql/execution/ResultNodesInfo.java
@@ -2,6 +2,7 @@
 
 import graphql.Internal;
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
 
 import java.util.concurrent.atomic.AtomicInteger;
 
@@ -14,6 +15,7 @@
  * </p>
  */
 @PublicApi
+@NullMarked
 public class ResultNodesInfo {
 
     public static final String MAX_RESULT_NODES = "__MAX_RESULT_NODES";
diff --git a/src/main/java/graphql/execution/ResultPath.java b/src/main/java/graphql/execution/ResultPath.java
index 20d13f1399..daa56bb411 100644
--- a/src/main/java/graphql/execution/ResultPath.java
+++ b/src/main/java/graphql/execution/ResultPath.java
@@ -4,6 +4,8 @@
 import graphql.AssertException;
 import graphql.PublicApi;
 import graphql.collect.ImmutableKit;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.LinkedList;
@@ -21,6 +23,7 @@
  * class represents that path as a series of segments.
  */
 @PublicApi
+@NullMarked
 public class ResultPath {
     private static final ResultPath ROOT_PATH = new ResultPath();
 
@@ -33,13 +36,13 @@ public static ResultPath rootPath() {
         return ROOT_PATH;
     }
 
-    private final ResultPath parent;
-    private final Object segment;
+    private final @Nullable ResultPath parent;
+    private final @Nullable Object segment;
 
     // hash is effective immutable but lazily initialized similar to the hash code of java.lang.String
     private int hash;
     // lazily initialized similar to hash - computed on first toString() call
-    private String toStringValue;
+    private @Nullable String toStringValue;
     private final int level;
 
     private ResultPath() {
@@ -72,7 +75,7 @@ public int getLevel() {
         return level;
     }
 
-    public ResultPath getPathWithoutListEnd() {
+    public @Nullable ResultPath getPathWithoutListEnd() {
         if (ROOT_PATH.equals(this)) {
             return ROOT_PATH;
         }
@@ -98,18 +101,18 @@ public boolean isNamedSegment() {
 
 
     public String getSegmentName() {
-        return (String) segment;
+        return (String) assertNotNull(segment);
     }
 
     public int getSegmentIndex() {
-        return (int) segment;
+        return (int) assertNotNull(segment);
     }
 
-    public Object getSegmentValue() {
+    public @Nullable Object getSegmentValue() {
         return segment;
     }
 
-    public ResultPath getParent() {
+    public @Nullable ResultPath getParent() {
         return parent;
     }
 
@@ -120,7 +123,7 @@ public ResultPath getParent() {
      *
      * @return a parsed execution path
      */
-    public static ResultPath parse(String pathString) {
+    public static ResultPath parse(@Nullable String pathString) {
         pathString = pathString == null ? "" : pathString;
         String finalPathString = pathString.trim();
         StringTokenizer st = new StringTokenizer(finalPathString, "/[]", true);
@@ -195,7 +198,7 @@ public ResultPath segment(int segment) {
      *
      * @return a new path with the last segment dropped off
      */
-    public ResultPath dropSegment() {
+    public @Nullable ResultPath dropSegment() {
         if (this == rootPath()) {
             return null;
         }
@@ -212,7 +215,7 @@ public ResultPath dropSegment() {
      */
     public ResultPath replaceSegment(int segment) {
         assertTrue(!ROOT_PATH.equals(this), "You MUST not call this with the root path");
-        return new ResultPath(parent, segment);
+        return new ResultPath(assertNotNull(parent, "parent must not be null for non-root path"), segment);
     }
 
     /**
@@ -225,7 +228,7 @@ public ResultPath replaceSegment(int segment) {
      */
     public ResultPath replaceSegment(String segment) {
         assertTrue(!ROOT_PATH.equals(this), "You MUST not call this with the root path");
-        return new ResultPath(parent, segment);
+        return new ResultPath(assertNotNull(parent, "parent must not be null for non-root path"), segment);
     }
 
 
@@ -252,12 +255,12 @@ public ResultPath append(ResultPath path) {
 
     public ResultPath sibling(String siblingField) {
         assertTrue(!ROOT_PATH.equals(this), "You MUST not call this with the root path");
-        return new ResultPath(this.parent, siblingField);
+        return new ResultPath(assertNotNull(this.parent, "parent must not be null for non-root path"), siblingField);
     }
 
     public ResultPath sibling(int siblingField) {
         assertTrue(!ROOT_PATH.equals(this), "You MUST not call this with the root path");
-        return new ResultPath(this.parent, siblingField);
+        return new ResultPath(assertNotNull(this.parent, "parent must not be null for non-root path"), siblingField);
     }
 
     /**
@@ -271,7 +274,7 @@ public List<Object> toList() {
         ResultPath p = this;
         while (p.segment != null) {
             list.addFirst(p.segment);
-            p = p.parent;
+            p = assertNotNull(p.parent, "non-root ResultPath must have a non-null parent");
         }
         return ImmutableList.copyOf(list);
     }
@@ -289,7 +292,7 @@ public List<String> getKeysOnly() {
             if (p.segment instanceof String) {
                 list.addFirst((String) p.segment);
             }
-            p = p.parent;
+            p = assertNotNull(p.parent, "non-root ResultPath must have a non-null parent");
         }
         return list;
     }
@@ -331,8 +334,8 @@ public boolean equals(Object o) {
             if (!Objects.equals(self.segment, that.segment)) {
                 return false;
             }
-            self = self.parent;
-            that = that.parent;
+            self = assertNotNull(self.parent, "non-root ResultPath must have a non-null parent");
+            that = assertNotNull(that.parent, "non-root ResultPath must have a non-null parent");
         }
 
         return self.isRootPath() && that.isRootPath();
diff --git a/src/main/java/graphql/execution/SimpleDataFetcherExceptionHandler.java b/src/main/java/graphql/execution/SimpleDataFetcherExceptionHandler.java
index 79e201a333..adfb4d0786 100644
--- a/src/main/java/graphql/execution/SimpleDataFetcherExceptionHandler.java
+++ b/src/main/java/graphql/execution/SimpleDataFetcherExceptionHandler.java
@@ -3,6 +3,7 @@
 import graphql.ExceptionWhileDataFetching;
 import graphql.PublicApi;
 import graphql.language.SourceLocation;
+import org.jspecify.annotations.NullMarked;
 
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionException;
@@ -12,6 +13,7 @@
  * into the error collection
  */
 @PublicApi
+@NullMarked
 public class SimpleDataFetcherExceptionHandler implements DataFetcherExceptionHandler {
 
     static final SimpleDataFetcherExceptionHandler defaultImpl = new SimpleDataFetcherExceptionHandler();
diff --git a/src/main/java/graphql/execution/SubscriptionExecutionStrategy.java b/src/main/java/graphql/execution/SubscriptionExecutionStrategy.java
index f1e1a9a919..89c77e967a 100644
--- a/src/main/java/graphql/execution/SubscriptionExecutionStrategy.java
+++ b/src/main/java/graphql/execution/SubscriptionExecutionStrategy.java
@@ -5,6 +5,8 @@
 import graphql.ExecutionResultImpl;
 import graphql.GraphQLContext;
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 import graphql.execution.incremental.AlternativeCallContext;
 import graphql.execution.instrumentation.ExecutionStrategyInstrumentationContext;
 import graphql.execution.instrumentation.Instrumentation;
@@ -25,6 +27,7 @@
 import java.util.concurrent.Flow;
 import java.util.function.Function;
 
+import static graphql.Assert.assertNotNull;
 import static graphql.execution.instrumentation.SimpleInstrumentationContext.nonNullCtx;
 import static java.util.Collections.singletonMap;
 
@@ -40,6 +43,7 @@
  * See <a href="https://www.reactive-streams.org/">https://www.reactive-streams.org/</a>
  */
 @PublicApi
+@NullMarked
 public class SubscriptionExecutionStrategy extends ExecutionStrategy {
 
     /**
@@ -132,7 +136,7 @@ private CompletableFuture<Publisher<Object>> createSourceEventStream(ExecutionCo
      * @return a reactive streams {@link Publisher} always
      */
     @SuppressWarnings("unchecked")
-    private static Publisher<Object> mkReactivePublisher(Object publisherObj) {
+    private static @Nullable Publisher<Object> mkReactivePublisher(@Nullable Object publisherObj) {
         if (publisherObj != null) {
             if (publisherObj instanceof Publisher) {
                 return (Publisher<Object>) publisherObj;
@@ -182,7 +186,7 @@ private CompletableFuture<ExecutionResult> executeSubscriptionEvent(ExecutionCon
         executionContext.getDataLoaderDispatcherStrategy().subscriptionEventCompletionDone(newParameters.getDeferredCallContext());
         CompletableFuture<ExecutionResult> overallResult = fieldValueInfo
                 .getFieldValueFuture()
-                .thenApply(val -> new ExecutionResultImpl(val, newParameters.getDeferredCallContext().getErrors()))
+                .thenApply(val -> new ExecutionResultImpl(val, assertNotNull(newParameters.getDeferredCallContext(), "deferredCallContext must not be null").getErrors()))
                 .thenApply(executionResult -> wrapWithRootFieldName(newParameters, executionResult));
 
         // dispatch instrumentation so they can know about each subscription event
@@ -206,7 +210,7 @@ private ExecutionResult wrapWithRootFieldName(ExecutionStrategyParameters parame
     }
 
     private String getRootFieldName(ExecutionStrategyParameters parameters) {
-        Field rootField = parameters.getField().getSingleField();
+        Field rootField = assertNotNull(parameters.getField(), "field must not be null").getSingleField();
         return rootField.getResultKey();
     }
 
@@ -214,7 +218,7 @@ private ExecutionStrategyParameters firstFieldOfSubscriptionSelection(ExecutionC
                                                                           ExecutionStrategyParameters parameters,
                                                                           boolean newCallContext) {
         MergedSelectionSet fields = parameters.getFields();
-        MergedField firstField = fields.getSubField(fields.getKeys().get(0));
+        MergedField firstField = assertNotNull(fields.getSubField(fields.getKeys().get(0)), "firstField must not be null");
 
         ResultPath fieldPath = parameters.getPath().segment(mkNameForPath(firstField.getSingleField()));
         NonNullableFieldValidator nonNullableFieldValidator = new NonNullableFieldValidator(executionContext);
@@ -234,7 +238,7 @@ private ExecutionStrategyParameters firstFieldOfSubscriptionSelection(ExecutionC
 
     private ExecutionStepInfo createSubscribedFieldStepInfo(ExecutionContext
                                                                     executionContext, ExecutionStrategyParameters parameters) {
-        Field field = parameters.getField().getSingleField();
+        Field field = assertNotNull(parameters.getField(), "field must not be null").getSingleField();
         GraphQLObjectType parentType = parameters.getExecutionStepInfo().getUnwrappedNonNullTypeAs();
         GraphQLFieldDefinition fieldDef = getFieldDef(executionContext.getGraphQLSchema(), parentType, field);
         return createExecutionStepInfo(executionContext, parameters, fieldDef, parentType);
diff --git a/src/main/java/graphql/execution/UnknownOperationException.java b/src/main/java/graphql/execution/UnknownOperationException.java
index 6ef523c9b1..13f427dff6 100644
--- a/src/main/java/graphql/execution/UnknownOperationException.java
+++ b/src/main/java/graphql/execution/UnknownOperationException.java
@@ -6,6 +6,8 @@
 import graphql.GraphQLException;
 import graphql.PublicApi;
 import graphql.language.SourceLocation;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.List;
 
@@ -15,13 +17,14 @@
  * contained in the GraphQL query.
  */
 @PublicApi
+@NullMarked
 public class UnknownOperationException extends GraphQLException implements GraphQLError {
     public UnknownOperationException(String message) {
         super(message);
     }
 
     @Override
-    public List<SourceLocation> getLocations() {
+    public @Nullable List<SourceLocation> getLocations() {
         return null;
     }
 
diff --git a/src/main/java/graphql/execution/UnresolvedTypeException.java b/src/main/java/graphql/execution/UnresolvedTypeException.java
index 4a6aad47d6..f964affb26 100644
--- a/src/main/java/graphql/execution/UnresolvedTypeException.java
+++ b/src/main/java/graphql/execution/UnresolvedTypeException.java
@@ -5,12 +5,14 @@
 import graphql.schema.GraphQLNamedOutputType;
 import graphql.schema.GraphQLType;
 import graphql.schema.GraphQLTypeUtil;
+import org.jspecify.annotations.NullMarked;
 
 /**
  * This is thrown if a {@link graphql.schema.TypeResolver} fails to give back a concrete type
  * or provides a type that doesn't implement the given interface or union.
  */
 @PublicApi
+@NullMarked
 public class UnresolvedTypeException extends GraphQLException {
 
     private final GraphQLNamedOutputType interfaceOrUnionType;
diff --git a/src/main/java/graphql/execution/conditional/ConditionalNodeDecision.java b/src/main/java/graphql/execution/conditional/ConditionalNodeDecision.java
index 69afc6bbc2..14056d70e9 100644
--- a/src/main/java/graphql/execution/conditional/ConditionalNodeDecision.java
+++ b/src/main/java/graphql/execution/conditional/ConditionalNodeDecision.java
@@ -1,6 +1,7 @@
 package graphql.execution.conditional;
 
 import graphql.ExperimentalApi;
+import org.jspecify.annotations.NullMarked;
 
 /**
  * This callback interface allows custom implementations to decide if a field is included in a query or not.
@@ -8,6 +9,7 @@
  * The default `@skip / @include` is built in, but you can create your own implementations to allow you to make
  * decisions on whether fields are considered part of a query.
  */
+@NullMarked
 @ExperimentalApi
 public interface ConditionalNodeDecision {
 
diff --git a/src/main/java/graphql/execution/directives/DirectivesResolver.java b/src/main/java/graphql/execution/directives/DirectivesResolver.java
index 4f177052e4..9fff2a514c 100644
--- a/src/main/java/graphql/execution/directives/DirectivesResolver.java
+++ b/src/main/java/graphql/execution/directives/DirectivesResolver.java
@@ -3,8 +3,10 @@
 import com.google.common.collect.BiMap;
 import com.google.common.collect.HashBiMap;
 import com.google.common.collect.ImmutableBiMap;
+import com.google.common.collect.ImmutableList;
 import graphql.GraphQLContext;
 import graphql.Internal;
+import graphql.collect.ImmutableKit;
 import graphql.execution.CoercedVariables;
 import graphql.execution.ValuesResolver;
 import graphql.language.Directive;
@@ -61,4 +63,34 @@ private void buildArguments(GraphQLDirective.Builder directiveBuilder,
             }
         });
     }
+
+    public ImmutableList<QueryAppliedDirective> toAppliedDirectives(List<Directive> directives, GraphQLSchema schema, CoercedVariables variables, GraphQLContext graphQLContext, Locale locale) {
+        BiMap<GraphQLDirective, Directive> directivesMap = resolveDirectives(directives, schema, variables, graphQLContext, locale);
+        return ImmutableKit.map(directivesMap.keySet(), this::toAppliedDirective);
+    }
+
+    /**
+     * This helps us remodel the applied GraphQLDirective back to the better modelled and named {@link QueryAppliedDirective}
+     *
+     * @param directive the directive to remodel
+     *
+     * @return a QueryAppliedDirective
+     */
+    public QueryAppliedDirective toAppliedDirective(GraphQLDirective directive) {
+        QueryAppliedDirective.Builder builder = QueryAppliedDirective.newDirective();
+        builder.name(directive.getName());
+        for (GraphQLArgument argument : directive.getArguments()) {
+            builder.argument(toAppliedArgument(argument));
+        }
+        return builder.build();
+    }
+
+    public QueryAppliedDirectiveArgument toAppliedArgument(GraphQLArgument argument) {
+        return QueryAppliedDirectiveArgument.newArgument()
+                .name(argument.getName())
+                .type(argument.getType())
+                .inputValueWithState(argument.getArgumentValue())
+                .build();
+    }
+
 }
diff --git a/src/main/java/graphql/execution/directives/OperationDirectivesResolver.java b/src/main/java/graphql/execution/directives/OperationDirectivesResolver.java
new file mode 100644
index 0000000000..b437593318
--- /dev/null
+++ b/src/main/java/graphql/execution/directives/OperationDirectivesResolver.java
@@ -0,0 +1,52 @@
+package graphql.execution.directives;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import graphql.GraphQLContext;
+import graphql.Internal;
+import graphql.execution.CoercedVariables;
+import graphql.language.Document;
+import graphql.language.OperationDefinition;
+import graphql.schema.GraphQLSchema;
+import graphql.util.FpKit;
+import org.jspecify.annotations.NullMarked;
+
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+
+@Internal
+@NullMarked
+public class OperationDirectivesResolver {
+
+    private final DirectivesResolver directivesResolver = new DirectivesResolver();
+
+    public ImmutableMap<OperationDefinition, ImmutableList<QueryAppliedDirective>> resolveDirectives(Document document, GraphQLSchema schema, CoercedVariables variables, GraphQLContext graphQLContext, Locale locale) {
+        ImmutableMap.Builder<OperationDefinition, ImmutableList<QueryAppliedDirective>> builder = ImmutableMap.builder();
+        for (OperationDefinition operationDefinition : document.getDefinitionsOfType(OperationDefinition.class)) {
+            builder.put(operationDefinition, resolveDirectives(operationDefinition, schema, variables, graphQLContext, locale));
+        }
+        return builder.build();
+    }
+
+    public ImmutableList<QueryAppliedDirective> resolveDirectives(OperationDefinition operationDefinition, GraphQLSchema schema, CoercedVariables variables, GraphQLContext graphQLContext, Locale locale) {
+        return directivesResolver.toAppliedDirectives(
+                operationDefinition.getDirectives(),
+                schema,
+                variables,
+                graphQLContext,
+                locale
+        );
+    }
+
+    public ImmutableMap<String, ImmutableList<QueryAppliedDirective>> resolveDirectivesByName(OperationDefinition operationDefinition, GraphQLSchema schema, CoercedVariables variables, GraphQLContext graphQLContext, Locale locale) {
+        List<QueryAppliedDirective> list = resolveDirectives(operationDefinition, schema, variables, graphQLContext, locale);
+        return toAppliedDirectivesByName(list);
+    }
+
+    public static ImmutableMap<String, ImmutableList<QueryAppliedDirective>> toAppliedDirectivesByName(List<QueryAppliedDirective> queryAppliedDirectives) {
+        Map<String, ImmutableList<QueryAppliedDirective>> immutableListMap = FpKit.groupingBy(queryAppliedDirectives, QueryAppliedDirective::getName);
+        return ImmutableMap.copyOf(immutableListMap);
+    }
+
+}
diff --git a/src/main/java/graphql/execution/directives/QueryAppliedDirective.java b/src/main/java/graphql/execution/directives/QueryAppliedDirective.java
index 84492143fd..d4c7785b9b 100644
--- a/src/main/java/graphql/execution/directives/QueryAppliedDirective.java
+++ b/src/main/java/graphql/execution/directives/QueryAppliedDirective.java
@@ -7,7 +7,8 @@
 import graphql.schema.GraphQLArgument;
 import graphql.schema.GraphQLDirective;
 import graphql.schema.GraphqlTypeBuilder;
-import org.jspecify.annotations.NonNull;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
 import org.jspecify.annotations.Nullable;
 
 import java.util.Collection;
@@ -32,6 +33,7 @@
  * <p>
  * See <a href="https://graphql.org/learn/queries/#directives">https://graphql.org/learn/queries/#directives</a> for more details on the concept.
  */
+@NullMarked
 @PublicApi
 public class QueryAppliedDirective {
 
@@ -47,7 +49,6 @@ private QueryAppliedDirective(String name, Directive definition, Collection<Quer
         this.definition = definition;
     }
 
-    @NonNull
     public String getName() {
         return name;
     }
@@ -107,6 +108,7 @@ public static Builder newDirective(QueryAppliedDirective existing) {
         return new Builder(existing);
     }
 
+    @NullUnmarked
     public static class Builder extends GraphqlTypeBuilder<Builder> {
 
         private final Map<String, QueryAppliedDirectiveArgument> arguments = new LinkedHashMap<>();
diff --git a/src/main/java/graphql/execution/directives/QueryAppliedDirectiveArgument.java b/src/main/java/graphql/execution/directives/QueryAppliedDirectiveArgument.java
index 8b772e91f7..880e82fab9 100644
--- a/src/main/java/graphql/execution/directives/QueryAppliedDirectiveArgument.java
+++ b/src/main/java/graphql/execution/directives/QueryAppliedDirectiveArgument.java
@@ -10,7 +10,8 @@
 import graphql.schema.GraphQLInputType;
 import graphql.schema.GraphqlTypeBuilder;
 import graphql.schema.InputValueWithState;
-import org.jspecify.annotations.NonNull;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
 import org.jspecify.annotations.Nullable;
 
 import java.util.Locale;
@@ -25,6 +26,7 @@
  * <p>
  * You can think of them as 'instances' of {@link GraphQLArgument}, when applied to a directive on a query element
  */
+@NullMarked
 @PublicApi
 public class QueryAppliedDirectiveArgument {
 
@@ -47,12 +49,10 @@ private QueryAppliedDirectiveArgument(String name,
         this.definition = definition;
     }
 
-    @NonNull
     public String getName() {
         return name;
     }
 
-    @NonNull
     public GraphQLInputType getType() {
         return originalType;
     }
@@ -64,7 +64,7 @@ public boolean hasSetValue() {
     /**
      * @return an input value with state for an applied directive argument
      */
-    public @NonNull InputValueWithState getArgumentValue() {
+    public InputValueWithState getArgumentValue() {
         return value;
     }
 
@@ -134,6 +134,7 @@ public String toString() {
                 '}';
     }
 
+    @NullUnmarked
     public static class Builder extends GraphqlTypeBuilder<Builder> {
 
         private InputValueWithState value = InputValueWithState.NOT_SET;
@@ -166,8 +167,8 @@ public Builder definition(Argument definition) {
          *
          * @return this builder
          */
-        public Builder valueLiteral(@NonNull Value<?> value) {
-            this.value = InputValueWithState.newLiteralValue(value);
+        public Builder valueLiteral(Value<?> value) {
+            this.value = InputValueWithState.newLiteralValue(assertNotNull(value));
             return this;
         }
 
@@ -181,7 +182,7 @@ public Builder valueProgrammatic(@Nullable Object value) {
             return this;
         }
 
-        public Builder inputValueWithState(@NonNull InputValueWithState value) {
+        public Builder inputValueWithState(InputValueWithState value) {
             this.value = Assert.assertNotNull(value);
             return this;
         }
diff --git a/src/main/java/graphql/execution/directives/QueryDirectives.java b/src/main/java/graphql/execution/directives/QueryDirectives.java
index 6eee9f9323..ff7baf6869 100644
--- a/src/main/java/graphql/execution/directives/QueryDirectives.java
+++ b/src/main/java/graphql/execution/directives/QueryDirectives.java
@@ -2,6 +2,7 @@
 
 import graphql.GraphQLContext;
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
 import graphql.execution.CoercedVariables;
 import graphql.execution.MergedField;
 import graphql.execution.NormalizedVariables;
@@ -30,6 +31,7 @@
  *
  * @see graphql.execution.MergedField
  */
+@NullMarked
 @PublicApi
 public interface QueryDirectives {
 
diff --git a/src/main/java/graphql/execution/directives/QueryDirectivesImpl.java b/src/main/java/graphql/execution/directives/QueryDirectivesImpl.java
index 87f00d6f97..c7c59ea092 100644
--- a/src/main/java/graphql/execution/directives/QueryDirectivesImpl.java
+++ b/src/main/java/graphql/execution/directives/QueryDirectivesImpl.java
@@ -80,7 +80,7 @@ private void computeValuesLazily() {
 
                 ImmutableList.Builder<QueryAppliedDirective> appliedDirectiveBuilder = ImmutableList.builder();
                 for (GraphQLDirective resolvedDirective : resolvedDirectives) {
-                    QueryAppliedDirective appliedDirective = toAppliedDirective(resolvedDirective);
+                    QueryAppliedDirective appliedDirective = directivesResolver.toAppliedDirective(resolvedDirective);
                     appliedDirectiveBuilder.add(appliedDirective);
                     gqlDirectiveCounterParts.put(resolvedDirective, appliedDirective);
                 }
@@ -125,23 +125,6 @@ private void computeValuesLazily() {
         });
     }
 
-    private QueryAppliedDirective toAppliedDirective(GraphQLDirective directive) {
-        QueryAppliedDirective.Builder builder = QueryAppliedDirective.newDirective();
-        builder.name(directive.getName());
-        for (GraphQLArgument argument : directive.getArguments()) {
-            builder.argument(toAppliedArgument(argument));
-        }
-        return builder.build();
-    }
-
-    private QueryAppliedDirectiveArgument toAppliedArgument(GraphQLArgument argument) {
-        return QueryAppliedDirectiveArgument.newArgument()
-                .name(argument.getName())
-                .type(argument.getType())
-                .inputValueWithState(argument.getArgumentValue())
-                .build();
-    }
-
 
     @Override
     public Map<Field, List<GraphQLDirective>> getImmediateDirectivesByField() {
diff --git a/src/main/java/graphql/execution/incremental/DeferredExecution.java b/src/main/java/graphql/execution/incremental/DeferredExecution.java
index ae63808989..b24ddc92b0 100644
--- a/src/main/java/graphql/execution/incremental/DeferredExecution.java
+++ b/src/main/java/graphql/execution/incremental/DeferredExecution.java
@@ -2,6 +2,7 @@
 
 import graphql.ExperimentalApi;
 import graphql.normalized.incremental.NormalizedDeferredExecution;
+import org.jspecify.annotations.NullMarked;
 import org.jspecify.annotations.Nullable;
 
 /**
@@ -11,10 +12,11 @@
  * for the normalized representation of @defer.
  */
 @ExperimentalApi
+@NullMarked
 public class DeferredExecution {
-    private final String label;
+    private final @Nullable String label;
 
-    public DeferredExecution(String label) {
+    public DeferredExecution(@Nullable String label) {
         this.label = label;
     }
 
diff --git a/src/main/java/graphql/execution/incremental/DeferredExecutionSupport.java b/src/main/java/graphql/execution/incremental/DeferredExecutionSupport.java
index 86965d701e..f7ddbfe6f7 100644
--- a/src/main/java/graphql/execution/incremental/DeferredExecutionSupport.java
+++ b/src/main/java/graphql/execution/incremental/DeferredExecutionSupport.java
@@ -128,9 +128,8 @@ public Set<IncrementalCall<? extends IncrementalPayload>> createCalls() {
 
         private DeferredFragmentCall createDeferredFragmentCall(DeferredExecution deferredExecution) {
             int level = parameters.getPath().getLevel() + 1;
-            AlternativeCallContext alternativeCallContext = new AlternativeCallContext(level, deferredFields.size());
-
             List<MergedField> mergedFields = deferredExecutionToFields.get(deferredExecution);
+            AlternativeCallContext alternativeCallContext = new AlternativeCallContext(level, mergedFields.size());
 
             List<Supplier<CompletableFuture<DeferredFragmentCall.FieldWithExecutionResult>>> calls = FpKit.arrayListSizedTo(mergedFields);
             for (MergedField currentField : mergedFields) {
diff --git a/src/main/java/graphql/execution/instrumentation/ChainedInstrumentation.java b/src/main/java/graphql/execution/instrumentation/ChainedInstrumentation.java
index 4ae65742bf..ebf2758e37 100644
--- a/src/main/java/graphql/execution/instrumentation/ChainedInstrumentation.java
+++ b/src/main/java/graphql/execution/instrumentation/ChainedInstrumentation.java
@@ -22,7 +22,7 @@
 import graphql.schema.DataFetcher;
 import graphql.schema.GraphQLSchema;
 import graphql.validation.ValidationError;
-import org.jspecify.annotations.NonNull;
+import org.jspecify.annotations.NullMarked;
 import org.jspecify.annotations.Nullable;
 
 import java.util.AbstractMap;
@@ -45,6 +45,7 @@
  * @see graphql.execution.instrumentation.Instrumentation
  */
 @PublicApi
+@NullMarked
 public class ChainedInstrumentation implements Instrumentation {
 
     // This class is inspired from https://github.com/leangen/graphql-spqr/blob/master/src/main/java/io/leangen/graphql/GraphQLRuntime.java#L80
@@ -66,7 +67,7 @@ public List<Instrumentation> getInstrumentations() {
         return instrumentations;
     }
 
-    private <T> InstrumentationContext<T> chainedCtx(InstrumentationState state, BiFunction<Instrumentation, InstrumentationState, InstrumentationContext<T>> mapper) {
+    private <T> @Nullable InstrumentationContext<T> chainedCtx(InstrumentationState state, BiFunction<Instrumentation, InstrumentationState, InstrumentationContext<T>> mapper) {
         // if we have zero or 1 instrumentations (and 1 is the most common), then we can avoid an object allocation
         // of the ChainedInstrumentationContext since it won't be needed
         if (instrumentations.isEmpty()) {
@@ -113,29 +114,29 @@ protected void chainedConsume(InstrumentationState state, BiConsumer<Instrumenta
     }
 
     @Override
-    public @NonNull CompletableFuture<InstrumentationState> createStateAsync(InstrumentationCreateStateParameters parameters) {
+    public CompletableFuture<InstrumentationState> createStateAsync(InstrumentationCreateStateParameters parameters) {
         return ChainedInstrumentationState.combineAll(instrumentations, parameters);
     }
 
     @Override
-    public InstrumentationContext<ExecutionResult> beginExecution(InstrumentationExecutionParameters parameters, InstrumentationState state) {
+    public @Nullable InstrumentationContext<ExecutionResult> beginExecution(InstrumentationExecutionParameters parameters, InstrumentationState state) {
         return chainedCtx(state, (instrumentation, specificState) -> instrumentation.beginExecution(parameters, specificState));
     }
 
 
     @Override
-    public InstrumentationContext<Document> beginParse(InstrumentationExecutionParameters parameters, InstrumentationState state) {
+    public @Nullable InstrumentationContext<Document> beginParse(InstrumentationExecutionParameters parameters, InstrumentationState state) {
         return chainedCtx(state, (instrumentation, specificState) -> instrumentation.beginParse(parameters, specificState));
     }
 
 
     @Override
-    public InstrumentationContext<List<ValidationError>> beginValidation(InstrumentationValidationParameters parameters, InstrumentationState state) {
+    public @Nullable InstrumentationContext<List<ValidationError>> beginValidation(InstrumentationValidationParameters parameters, InstrumentationState state) {
         return chainedCtx(state, (instrumentation, specificState) -> instrumentation.beginValidation(parameters, specificState));
     }
 
     @Override
-    public InstrumentationContext<ExecutionResult> beginExecuteOperation(InstrumentationExecuteOperationParameters parameters, InstrumentationState state) {
+    public @Nullable InstrumentationContext<ExecutionResult> beginExecuteOperation(InstrumentationExecuteOperationParameters parameters, InstrumentationState state) {
         return chainedCtx(state, (instrumentation, specificState) -> instrumentation.beginExecuteOperation(parameters, specificState));
     }
 
@@ -145,7 +146,7 @@ public InstrumentationContext<ExecutionResult> beginExecuteOperation(Instrumenta
     }
 
     @Override
-    public ExecutionStrategyInstrumentationContext beginExecutionStrategy(InstrumentationExecutionStrategyParameters parameters, InstrumentationState state) {
+    public @Nullable ExecutionStrategyInstrumentationContext beginExecutionStrategy(InstrumentationExecutionStrategyParameters parameters, InstrumentationState state) {
         if (instrumentations.isEmpty()) {
             return ExecutionStrategyInstrumentationContext.NOOP;
         }
@@ -172,12 +173,12 @@ public ExecutionStrategyInstrumentationContext beginExecutionStrategy(Instrument
 
     @ExperimentalApi
     @Override
-    public InstrumentationContext<Object> beginDeferredField(InstrumentationFieldParameters parameters, InstrumentationState state) {
+    public @Nullable InstrumentationContext<Object> beginDeferredField(InstrumentationFieldParameters parameters, InstrumentationState state) {
         return chainedCtx(state, (instrumentation, specificState) -> instrumentation.beginDeferredField(parameters, specificState));
     }
 
     @Override
-    public InstrumentationContext<ExecutionResult> beginSubscribedFieldEvent(InstrumentationFieldParameters parameters, InstrumentationState state) {
+    public @Nullable InstrumentationContext<ExecutionResult> beginSubscribedFieldEvent(InstrumentationFieldParameters parameters, InstrumentationState state) {
         return chainedCtx(state, (instrumentation, specificState) -> instrumentation.beginSubscribedFieldEvent(parameters, specificState));
     }
 
@@ -188,12 +189,12 @@ public InstrumentationContext<ExecutionResult> beginSubscribedFieldEvent(Instrum
 
     @SuppressWarnings("deprecation")
     @Override
-    public InstrumentationContext<Object> beginFieldFetch(InstrumentationFieldFetchParameters parameters, InstrumentationState state) {
+    public @Nullable InstrumentationContext<Object> beginFieldFetch(InstrumentationFieldFetchParameters parameters, InstrumentationState state) {
         return chainedCtx(state, (instrumentation, specificState) -> instrumentation.beginFieldFetch(parameters, specificState));
     }
 
     @Override
-    public FieldFetchingInstrumentationContext beginFieldFetching(InstrumentationFieldFetchParameters parameters, InstrumentationState state) {
+    public @Nullable FieldFetchingInstrumentationContext beginFieldFetching(InstrumentationFieldFetchParameters parameters, InstrumentationState state) {
         if (instrumentations.isEmpty()) {
             return FieldFetchingInstrumentationContext.NOOP;
         }
@@ -217,41 +218,35 @@ public FieldFetchingInstrumentationContext beginFieldFetching(InstrumentationFie
         return chainedCtx(state, (instrumentation, specificState) -> instrumentation.beginFieldListCompletion(parameters, specificState));
     }
 
-    @NonNull
     @Override
     public ExecutionInput instrumentExecutionInput(ExecutionInput executionInput, InstrumentationExecutionParameters parameters, InstrumentationState state) {
         return chainedInstrument(state, executionInput, (instrumentation, specificState, accumulator) -> instrumentation.instrumentExecutionInput(accumulator, parameters, specificState));
     }
 
-    @NonNull
     @Override
     public DocumentAndVariables instrumentDocumentAndVariables(DocumentAndVariables documentAndVariables, InstrumentationExecutionParameters parameters, InstrumentationState state) {
         return chainedInstrument(state, documentAndVariables, (instrumentation, specificState, accumulator) ->
                 instrumentation.instrumentDocumentAndVariables(accumulator, parameters, specificState));
     }
 
-    @NonNull
     @Override
     public GraphQLSchema instrumentSchema(GraphQLSchema schema, InstrumentationExecutionParameters parameters, InstrumentationState state) {
         return chainedInstrument(state, schema, (instrumentation, specificState, accumulator) ->
                 instrumentation.instrumentSchema(accumulator, parameters, specificState));
     }
 
-    @NonNull
     @Override
     public ExecutionContext instrumentExecutionContext(ExecutionContext executionContext, InstrumentationExecutionParameters parameters, InstrumentationState state) {
         return chainedInstrument(state, executionContext, (instrumentation, specificState, accumulator) ->
                 instrumentation.instrumentExecutionContext(accumulator, parameters, specificState));
     }
 
-    @NonNull
     @Override
     public DataFetcher<?> instrumentDataFetcher(DataFetcher<?> dataFetcher, InstrumentationFieldFetchParameters parameters, InstrumentationState state) {
         return chainedInstrument(state, dataFetcher, (Instrumentation instrumentation, InstrumentationState specificState, DataFetcher<?> accumulator) ->
                 instrumentation.instrumentDataFetcher(accumulator, parameters, specificState));
     }
 
-    @NonNull
     @Override
     public CompletableFuture<ExecutionResult> instrumentExecutionResult(ExecutionResult executionResult, InstrumentationExecutionParameters parameters, InstrumentationState state) {
         ImmutableList<Map.Entry<Instrumentation, InstrumentationState>> entries = chainedMapAndDropNulls(state, AbstractMap.SimpleEntry::new);
@@ -300,7 +295,7 @@ public void onDispatched() {
         }
 
         @Override
-        public void onCompleted(T result, Throwable t) {
+        public void onCompleted(@Nullable T result, @Nullable Throwable t) {
             contexts.forEach(context -> context.onCompleted(result, t));
         }
     }
@@ -319,7 +314,7 @@ public void onDispatched() {
         }
 
         @Override
-        public void onCompleted(ExecutionResult result, Throwable t) {
+        public void onCompleted(@Nullable ExecutionResult result, @Nullable Throwable t) {
             contexts.forEach(context -> context.onCompleted(result, t));
         }
 
@@ -348,7 +343,7 @@ public void onDispatched() {
         }
 
         @Override
-        public void onCompleted(Map<String, Object> result, Throwable t) {
+        public void onCompleted(@Nullable Map<String, Object> result, @Nullable Throwable t) {
             contexts.forEach(context -> context.onCompleted(result, t));
         }
 
@@ -387,7 +382,7 @@ public void onExceptionHandled(DataFetcherResult<Object> dataFetcherResult) {
         }
 
         @Override
-        public void onCompleted(Object result, Throwable t) {
+        public void onCompleted(@Nullable Object result, @Nullable Throwable t) {
             contexts.forEach(context -> context.onCompleted(result, t));
         }
     }
@@ -407,7 +402,7 @@ public void onDispatched() {
         }
 
         @Override
-        public void onCompleted(Object result, Throwable t) {
+        public void onCompleted(@Nullable Object result, @Nullable Throwable t) {
             contexts.forEach(context -> context.onCompleted(result, t));
         }
     }
diff --git a/src/main/java/graphql/execution/instrumentation/DocumentAndVariables.java b/src/main/java/graphql/execution/instrumentation/DocumentAndVariables.java
index 7b5c4c4978..7d7a43117d 100644
--- a/src/main/java/graphql/execution/instrumentation/DocumentAndVariables.java
+++ b/src/main/java/graphql/execution/instrumentation/DocumentAndVariables.java
@@ -3,6 +3,8 @@
 import graphql.PublicApi;
 import graphql.collect.ImmutableMapWithNullValues;
 import graphql.language.Document;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
 
 import java.util.Map;
 import java.util.function.Consumer;
@@ -10,6 +12,7 @@
 import static graphql.Assert.assertNotNull;
 
 @PublicApi
+@NullMarked
 public class DocumentAndVariables {
     private final Document document;
     private final ImmutableMapWithNullValues<String, Object> variables;
@@ -37,6 +40,7 @@ public static Builder newDocumentAndVariables() {
         return new Builder();
     }
 
+    @NullUnmarked
     public static class Builder {
         private Document document;
         private Map<String, Object> variables;
diff --git a/src/main/java/graphql/execution/instrumentation/Instrumentation.java b/src/main/java/graphql/execution/instrumentation/Instrumentation.java
index 565c4333da..2bfb6eadcf 100644
--- a/src/main/java/graphql/execution/instrumentation/Instrumentation.java
+++ b/src/main/java/graphql/execution/instrumentation/Instrumentation.java
@@ -175,6 +175,7 @@ default ExecuteObjectInstrumentationContext beginExecuteObject(InstrumentationEx
      * @return a nullable {@link InstrumentationContext} object that will be called back when the step ends (assuming it's not null)
      */
     @ExperimentalApi
+    @Nullable
     default InstrumentationContext<Object> beginDeferredField(InstrumentationFieldParameters parameters, InstrumentationState state) {
         return noOp();
     }
diff --git a/src/main/java/graphql/execution/instrumentation/NoContextChainedInstrumentation.java b/src/main/java/graphql/execution/instrumentation/NoContextChainedInstrumentation.java
index 8d56230825..719376819a 100644
--- a/src/main/java/graphql/execution/instrumentation/NoContextChainedInstrumentation.java
+++ b/src/main/java/graphql/execution/instrumentation/NoContextChainedInstrumentation.java
@@ -12,6 +12,7 @@
 import graphql.execution.instrumentation.parameters.InstrumentationValidationParameters;
 import graphql.language.Document;
 import graphql.validation.ValidationError;
+import org.jspecify.annotations.NullMarked;
 import org.jspecify.annotations.Nullable;
 
 import java.util.List;
@@ -39,6 +40,7 @@
  * as itself.
  */
 @PublicApi
+@NullMarked
 public class NoContextChainedInstrumentation extends ChainedInstrumentation {
 
     public NoContextChainedInstrumentation(List<Instrumentation> instrumentations) {
@@ -49,28 +51,28 @@ public NoContextChainedInstrumentation(Instrumentation... instrumentations) {
         super(instrumentations);
     }
 
-    private <T> T runAll(InstrumentationState state, BiConsumer<Instrumentation, InstrumentationState> stateConsumer) {
+    private <T> @Nullable T runAll(InstrumentationState state, BiConsumer<Instrumentation, InstrumentationState> stateConsumer) {
         chainedConsume(state, stateConsumer);
         return null;
     }
 
     @Override
-    public InstrumentationContext<ExecutionResult> beginExecution(InstrumentationExecutionParameters parameters, InstrumentationState state) {
+    public @Nullable InstrumentationContext<ExecutionResult> beginExecution(InstrumentationExecutionParameters parameters, InstrumentationState state) {
         return runAll(state, (instrumentation, specificState) -> instrumentation.beginExecution(parameters, specificState));
     }
 
     @Override
-    public InstrumentationContext<Document> beginParse(InstrumentationExecutionParameters parameters, InstrumentationState state) {
+    public @Nullable InstrumentationContext<Document> beginParse(InstrumentationExecutionParameters parameters, InstrumentationState state) {
         return runAll(state, (instrumentation, specificState) -> instrumentation.beginParse(parameters, specificState));
     }
 
     @Override
-    public InstrumentationContext<List<ValidationError>> beginValidation(InstrumentationValidationParameters parameters, InstrumentationState state) {
+    public @Nullable InstrumentationContext<List<ValidationError>> beginValidation(InstrumentationValidationParameters parameters, InstrumentationState state) {
         return runAll(state, (instrumentation, specificState) -> instrumentation.beginValidation(parameters, specificState));
     }
 
     @Override
-    public InstrumentationContext<ExecutionResult> beginExecuteOperation(InstrumentationExecuteOperationParameters parameters, InstrumentationState state) {
+    public @Nullable InstrumentationContext<ExecutionResult> beginExecuteOperation(InstrumentationExecuteOperationParameters parameters, InstrumentationState state) {
         return runAll(state, (instrumentation, specificState) -> instrumentation.beginExecuteOperation(parameters, specificState));
     }
 
@@ -80,7 +82,7 @@ public InstrumentationContext<ExecutionResult> beginExecuteOperation(Instrumenta
     }
 
     @Override
-    public ExecutionStrategyInstrumentationContext beginExecutionStrategy(InstrumentationExecutionStrategyParameters parameters, InstrumentationState state) {
+    public @Nullable ExecutionStrategyInstrumentationContext beginExecutionStrategy(InstrumentationExecutionStrategyParameters parameters, InstrumentationState state) {
         return runAll(state, (instrumentation, specificState) -> instrumentation.beginExecutionStrategy(parameters, specificState));
     }
 
@@ -90,12 +92,12 @@ public ExecutionStrategyInstrumentationContext beginExecutionStrategy(Instrument
     }
 
     @Override
-    public InstrumentationContext<Object> beginDeferredField(InstrumentationFieldParameters parameters, InstrumentationState state) {
+    public @Nullable InstrumentationContext<Object> beginDeferredField(InstrumentationFieldParameters parameters, InstrumentationState state) {
         return runAll(state, (instrumentation, specificState) -> instrumentation.beginDeferredField(parameters, specificState));
     }
 
     @Override
-    public InstrumentationContext<ExecutionResult> beginSubscribedFieldEvent(InstrumentationFieldParameters parameters, InstrumentationState state) {
+    public @Nullable InstrumentationContext<ExecutionResult> beginSubscribedFieldEvent(InstrumentationFieldParameters parameters, InstrumentationState state) {
         return runAll(state, (instrumentation, specificState) -> instrumentation.beginSubscribedFieldEvent(parameters, specificState));
     }
 
@@ -105,12 +107,12 @@ public InstrumentationContext<ExecutionResult> beginSubscribedFieldEvent(Instrum
     }
 
     @Override
-    public InstrumentationContext<Object> beginFieldFetch(InstrumentationFieldFetchParameters parameters, InstrumentationState state) {
+    public @Nullable InstrumentationContext<Object> beginFieldFetch(InstrumentationFieldFetchParameters parameters, InstrumentationState state) {
         return runAll(state, (instrumentation, specificState) -> instrumentation.beginFieldFetch(parameters, specificState));
     }
 
     @Override
-    public FieldFetchingInstrumentationContext beginFieldFetching(InstrumentationFieldFetchParameters parameters, InstrumentationState state) {
+    public @Nullable FieldFetchingInstrumentationContext beginFieldFetching(InstrumentationFieldFetchParameters parameters, InstrumentationState state) {
         return runAll(state, (instrumentation, specificState) -> instrumentation.beginFieldFetching(parameters, specificState));
     }
 
diff --git a/src/main/java/graphql/execution/instrumentation/SimpleInstrumentation.java b/src/main/java/graphql/execution/instrumentation/SimpleInstrumentation.java
index d2df536e75..9f9c2d272e 100644
--- a/src/main/java/graphql/execution/instrumentation/SimpleInstrumentation.java
+++ b/src/main/java/graphql/execution/instrumentation/SimpleInstrumentation.java
@@ -1,6 +1,7 @@
 package graphql.execution.instrumentation;
 
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
 
 /**
  * An implementation of {@link graphql.execution.instrumentation.Instrumentation} that does nothing.  It can be used
@@ -11,6 +12,7 @@
  * @deprecated use {@link SimplePerformantInstrumentation} instead as a base class.
  */
 @PublicApi
+@NullMarked
 @Deprecated(since = "2022-10-05")
 public class SimpleInstrumentation implements Instrumentation {
 
diff --git a/src/main/java/graphql/execution/instrumentation/SimpleInstrumentationContext.java b/src/main/java/graphql/execution/instrumentation/SimpleInstrumentationContext.java
index 0abfc744d6..1a3d240c65 100644
--- a/src/main/java/graphql/execution/instrumentation/SimpleInstrumentationContext.java
+++ b/src/main/java/graphql/execution/instrumentation/SimpleInstrumentationContext.java
@@ -1,7 +1,8 @@
 package graphql.execution.instrumentation;
 
 import graphql.PublicApi;
-import org.jspecify.annotations.NonNull;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.function.BiConsumer;
 
@@ -9,6 +10,7 @@
  * A simple implementation of {@link InstrumentationContext}
  */
 @PublicApi
+@NullMarked
 public class SimpleInstrumentationContext<T> implements InstrumentationContext<T> {
 
     private static final InstrumentationContext<Object> NO_OP = new InstrumentationContext<Object>() {
@@ -17,7 +19,7 @@ public void onDispatched() {
         }
 
         @Override
-        public void onCompleted(Object result, Throwable t) {
+        public void onCompleted(@Nullable Object result, @Nullable Throwable t) {
         }
     };
 
@@ -41,19 +43,18 @@ public static <T> InstrumentationContext<T> noOp() {
      *
      * @return a non null {@link InstrumentationContext} that maybe a no-op
      */
-    @NonNull
-    public static <T> InstrumentationContext<T> nonNullCtx(InstrumentationContext<T> nullableContext) {
+    public static <T> InstrumentationContext<T> nonNullCtx(@Nullable InstrumentationContext<T> nullableContext) {
         return nullableContext == null ? noOp() : nullableContext;
     }
 
-    private final BiConsumer<T, Throwable> codeToRunOnComplete;
-    private final Runnable codeToRunOnDispatch;
+    private final @Nullable BiConsumer<T, Throwable> codeToRunOnComplete;
+    private final @Nullable Runnable codeToRunOnDispatch;
 
     public SimpleInstrumentationContext() {
         this(null, null);
     }
 
-    private SimpleInstrumentationContext(Runnable codeToRunOnDispatch, BiConsumer<T, Throwable> codeToRunOnComplete) {
+    private SimpleInstrumentationContext(@Nullable Runnable codeToRunOnDispatch, @Nullable BiConsumer<T, Throwable> codeToRunOnComplete) {
         this.codeToRunOnComplete = codeToRunOnComplete;
         this.codeToRunOnDispatch = codeToRunOnDispatch;
     }
@@ -66,7 +67,7 @@ public void onDispatched() {
     }
 
     @Override
-    public void onCompleted(T result, Throwable t) {
+    public void onCompleted(@Nullable T result, @Nullable Throwable t) {
         if (codeToRunOnComplete != null) {
             codeToRunOnComplete.accept(result, t);
         }
@@ -99,7 +100,7 @@ public static <U> SimpleInstrumentationContext<U> whenCompleted(BiConsumer<U, Th
     }
 
     public static <T> BiConsumer<? super T, ? super Throwable> completeInstrumentationCtxCF(
-            InstrumentationContext<T> instrumentationContext) {
+            @Nullable InstrumentationContext<T> instrumentationContext) {
         return (result, throwable) -> {
             nonNullCtx(instrumentationContext).onCompleted(result, throwable);
         };
diff --git a/src/main/java/graphql/execution/instrumentation/SimplePerformantInstrumentation.java b/src/main/java/graphql/execution/instrumentation/SimplePerformantInstrumentation.java
index 26f30714fa..a2cb05b592 100644
--- a/src/main/java/graphql/execution/instrumentation/SimplePerformantInstrumentation.java
+++ b/src/main/java/graphql/execution/instrumentation/SimplePerformantInstrumentation.java
@@ -16,7 +16,7 @@
 import graphql.schema.DataFetcher;
 import graphql.schema.GraphQLSchema;
 import graphql.validation.ValidationError;
-import org.jspecify.annotations.NonNull;
+import org.jspecify.annotations.NullMarked;
 import org.jspecify.annotations.Nullable;
 
 import java.util.List;
@@ -38,6 +38,7 @@
  */
 @SuppressWarnings("deprecation")
 @PublicApi
+@NullMarked
 public class SimplePerformantInstrumentation implements Instrumentation {
 
     /**
@@ -112,32 +113,32 @@ public class SimplePerformantInstrumentation implements Instrumentation {
     }
 
     @Override
-    public @NonNull ExecutionInput instrumentExecutionInput(ExecutionInput executionInput, InstrumentationExecutionParameters parameters, InstrumentationState state) {
+    public ExecutionInput instrumentExecutionInput(ExecutionInput executionInput, InstrumentationExecutionParameters parameters, InstrumentationState state) {
         return executionInput;
     }
 
     @Override
-    public @NonNull DocumentAndVariables instrumentDocumentAndVariables(DocumentAndVariables documentAndVariables, InstrumentationExecutionParameters parameters, InstrumentationState state) {
+    public DocumentAndVariables instrumentDocumentAndVariables(DocumentAndVariables documentAndVariables, InstrumentationExecutionParameters parameters, InstrumentationState state) {
         return documentAndVariables;
     }
 
     @Override
-    public @NonNull GraphQLSchema instrumentSchema(GraphQLSchema schema, InstrumentationExecutionParameters parameters, InstrumentationState state) {
+    public GraphQLSchema instrumentSchema(GraphQLSchema schema, InstrumentationExecutionParameters parameters, InstrumentationState state) {
         return schema;
     }
 
     @Override
-    public @NonNull ExecutionContext instrumentExecutionContext(ExecutionContext executionContext, InstrumentationExecutionParameters parameters, InstrumentationState state) {
+    public ExecutionContext instrumentExecutionContext(ExecutionContext executionContext, InstrumentationExecutionParameters parameters, InstrumentationState state) {
         return executionContext;
     }
 
     @Override
-    public @NonNull DataFetcher<?> instrumentDataFetcher(DataFetcher<?> dataFetcher, InstrumentationFieldFetchParameters parameters, InstrumentationState state) {
+    public DataFetcher<?> instrumentDataFetcher(DataFetcher<?> dataFetcher, InstrumentationFieldFetchParameters parameters, InstrumentationState state) {
         return dataFetcher;
     }
 
     @Override
-    public @NonNull CompletableFuture<ExecutionResult> instrumentExecutionResult(ExecutionResult executionResult, InstrumentationExecutionParameters parameters, InstrumentationState state) {
+    public CompletableFuture<ExecutionResult> instrumentExecutionResult(ExecutionResult executionResult, InstrumentationExecutionParameters parameters, InstrumentationState state) {
         return CompletableFuture.completedFuture(executionResult);
     }
 }
diff --git a/src/main/java/graphql/execution/instrumentation/dataloader/ExhaustedDataLoaderDispatchStrategy.java b/src/main/java/graphql/execution/instrumentation/dataloader/ExhaustedDataLoaderDispatchStrategy.java
index f237622ecb..d7c7669f35 100644
--- a/src/main/java/graphql/execution/instrumentation/dataloader/ExhaustedDataLoaderDispatchStrategy.java
+++ b/src/main/java/graphql/execution/instrumentation/dataloader/ExhaustedDataLoaderDispatchStrategy.java
@@ -9,6 +9,7 @@
 import graphql.execution.incremental.AlternativeCallContext;
 import org.dataloader.DataLoader;
 import org.dataloader.DataLoaderRegistry;
+import graphql.VisibleForTesting;
 import org.jspecify.annotations.NullMarked;
 import org.jspecify.annotations.Nullable;
 
@@ -31,7 +32,8 @@ public class ExhaustedDataLoaderDispatchStrategy implements DataLoaderDispatchSt
     private final Map<AlternativeCallContext, CallStack> alternativeCallContextMap = new ConcurrentHashMap<>();
 
 
-    private static class CallStack {
+    @VisibleForTesting
+    static class CallStack {
 
         // 30 bits for objectRunningCount
         // 1 bit for dataLoaderToDispatch
@@ -127,7 +129,12 @@ public void clear() {
     }
 
     public ExhaustedDataLoaderDispatchStrategy(ExecutionContext executionContext) {
-        this.initialCallStack = new CallStack();
+        this(executionContext, new CallStack());
+    }
+
+    @VisibleForTesting
+    ExhaustedDataLoaderDispatchStrategy(ExecutionContext executionContext, CallStack callStack) {
+        this.initialCallStack = callStack;
         this.executionContext = executionContext;
 
         this.profiler = executionContext.getProfiler();
diff --git a/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java b/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java
index e6bfc3f740..0626d19af3 100644
--- a/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java
+++ b/src/main/java/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy.java
@@ -13,6 +13,7 @@
 import graphql.schema.DataFetchingEnvironment;
 import org.dataloader.DataLoader;
 import org.dataloader.DataLoaderRegistry;
+import graphql.VisibleForTesting;
 import org.jspecify.annotations.NullMarked;
 import org.jspecify.annotations.Nullable;
 
@@ -30,7 +31,8 @@
 @NullMarked
 public class PerLevelDataLoaderDispatchStrategy implements DataLoaderDispatchStrategy {
 
-    private final CallStack initialCallStack;
+    @VisibleForTesting
+    final CallStack initialCallStack;
     private final ExecutionContext executionContext;
     private final boolean enableDataLoaderChaining;
 
@@ -145,7 +147,8 @@ public void clear() {
 
     }
 
-    private static class CallStack {
+    // package-private for testing
+    static class CallStack {
 
         /**
          * We track three things per level:
@@ -177,8 +180,10 @@ private static class CallStack {
          */
 
         static class StateForLevel {
-            private final int happenedCompletionFinishedCount;
-            private final int happenedExecuteObjectCalls;
+            @VisibleForTesting
+            final int happenedCompletionFinishedCount;
+            @VisibleForTesting
+            final int happenedExecuteObjectCalls;
 
 
             public StateForLevel() {
@@ -216,7 +221,8 @@ public StateForLevel increaseHappenedExecuteObjectCalls() {
 
         private final Map<Integer, AtomicReference<StateForLevel>> stateForLevelMap = new ConcurrentHashMap<>();
 
-        private final Set<Integer> dispatchedLevels = ConcurrentHashMap.newKeySet();
+        @VisibleForTesting
+        final Set<Integer> dispatchedLevels = ConcurrentHashMap.newKeySet();
 
         public ChainedDLStack chainedDLStack = new ChainedDLStack();
 
@@ -439,7 +445,8 @@ private CallStack getCallStack(@Nullable AlternativeCallContext alternativeCallC
     }
 
 
-    private boolean markLevelAsDispatchedIfReady(int level, CallStack callStack) {
+    @VisibleForTesting
+    boolean markLevelAsDispatchedIfReady(int level, CallStack callStack) {
         boolean ready = isLevelReady(level, callStack);
         if (ready) {
             if (!callStack.dispatchedLevels.add(level)) {
diff --git a/src/main/java/graphql/execution/instrumentation/fieldvalidation/FieldAndArguments.java b/src/main/java/graphql/execution/instrumentation/fieldvalidation/FieldAndArguments.java
index 3ad6bc3e9c..9a0e2dfa4c 100644
--- a/src/main/java/graphql/execution/instrumentation/fieldvalidation/FieldAndArguments.java
+++ b/src/main/java/graphql/execution/instrumentation/fieldvalidation/FieldAndArguments.java
@@ -5,6 +5,8 @@
 import graphql.language.Field;
 import graphql.schema.GraphQLCompositeType;
 import graphql.schema.GraphQLFieldDefinition;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.Map;
 
@@ -12,6 +14,7 @@
  * This represents a field and its arguments that may be validated.
  */
 @PublicApi
+@NullMarked
 public interface FieldAndArguments {
 
     /**
@@ -32,7 +35,7 @@ public interface FieldAndArguments {
     /**
      * @return the parent arguments or null if there is no parent
      */
-    FieldAndArguments getParentFieldAndArguments();
+    @Nullable FieldAndArguments getParentFieldAndArguments();
 
     /**
      * @return the path to this field
@@ -56,5 +59,5 @@ public interface FieldAndArguments {
      * @return a cast object of type T
      */
     @SuppressWarnings("TypeParameterUnusedInFormals")
-    <T> T getArgumentValue(String argumentName);
+    <T> @Nullable T getArgumentValue(String argumentName);
 }
diff --git a/src/main/java/graphql/execution/instrumentation/fieldvalidation/FieldValidationEnvironment.java b/src/main/java/graphql/execution/instrumentation/fieldvalidation/FieldValidationEnvironment.java
index 047c3e7831..467e96610e 100644
--- a/src/main/java/graphql/execution/instrumentation/fieldvalidation/FieldValidationEnvironment.java
+++ b/src/main/java/graphql/execution/instrumentation/fieldvalidation/FieldValidationEnvironment.java
@@ -4,6 +4,7 @@
 import graphql.PublicApi;
 import graphql.execution.ExecutionContext;
 import graphql.execution.ResultPath;
+import org.jspecify.annotations.NullMarked;
 
 import java.util.List;
 import java.util.Map;
@@ -21,6 +22,7 @@
  * @see FieldAndArguments
  */
 @PublicApi
+@NullMarked
 public interface FieldValidationEnvironment {
 
     /**
diff --git a/src/main/java/graphql/execution/instrumentation/fieldvalidation/FieldValidationInstrumentation.java b/src/main/java/graphql/execution/instrumentation/fieldvalidation/FieldValidationInstrumentation.java
index 408fd261be..bea5d52577 100644
--- a/src/main/java/graphql/execution/instrumentation/fieldvalidation/FieldValidationInstrumentation.java
+++ b/src/main/java/graphql/execution/instrumentation/fieldvalidation/FieldValidationInstrumentation.java
@@ -8,6 +8,7 @@
 import graphql.execution.instrumentation.InstrumentationState;
 import graphql.execution.instrumentation.SimplePerformantInstrumentation;
 import graphql.execution.instrumentation.parameters.InstrumentationExecuteOperationParameters;
+import org.jspecify.annotations.NullMarked;
 import org.jspecify.annotations.Nullable;
 
 import java.util.List;
@@ -23,6 +24,7 @@
  *
  * @see FieldValidation
  */
+@NullMarked
 @PublicApi
 public class FieldValidationInstrumentation extends SimplePerformantInstrumentation {
 
diff --git a/src/main/java/graphql/execution/instrumentation/fieldvalidation/SimpleFieldValidation.java b/src/main/java/graphql/execution/instrumentation/fieldvalidation/SimpleFieldValidation.java
index 9f0a340f19..cebbac5dd8 100644
--- a/src/main/java/graphql/execution/instrumentation/fieldvalidation/SimpleFieldValidation.java
+++ b/src/main/java/graphql/execution/instrumentation/fieldvalidation/SimpleFieldValidation.java
@@ -4,6 +4,7 @@
 import graphql.GraphQLError;
 import graphql.PublicApi;
 import graphql.execution.ResultPath;
+import org.jspecify.annotations.NullMarked;
 
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
@@ -19,6 +20,7 @@
  * Use {@link #addRule(ResultPath, java.util.function.BiFunction)} to supply the rule callbacks where
  * you implement your specific business logic
  */
+@NullMarked
 @PublicApi
 public class SimpleFieldValidation implements FieldValidation {
 
diff --git a/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationCreateStateParameters.java b/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationCreateStateParameters.java
index da07ee2669..cc045ea1ce 100644
--- a/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationCreateStateParameters.java
+++ b/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationCreateStateParameters.java
@@ -3,10 +3,12 @@
 import graphql.ExecutionInput;
 import graphql.PublicApi;
 import graphql.schema.GraphQLSchema;
+import org.jspecify.annotations.NullMarked;
 
 /**
  * Parameters sent to {@link graphql.execution.instrumentation.Instrumentation} methods
  */
+@NullMarked
 @PublicApi
 public class InstrumentationCreateStateParameters {
     private final GraphQLSchema schema;
diff --git a/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationExecuteOperationParameters.java b/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationExecuteOperationParameters.java
index 69587f3f44..0f8bb54c04 100644
--- a/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationExecuteOperationParameters.java
+++ b/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationExecuteOperationParameters.java
@@ -3,10 +3,12 @@
 import graphql.PublicApi;
 import graphql.execution.ExecutionContext;
 import graphql.execution.instrumentation.Instrumentation;
+import org.jspecify.annotations.NullMarked;
 
 /**
  * Parameters sent to {@link Instrumentation} methods
  */
+@NullMarked
 @SuppressWarnings("TypeParameterUnusedInFormals")
 @PublicApi
 public class InstrumentationExecuteOperationParameters {
diff --git a/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationExecutionParameters.java b/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationExecutionParameters.java
index 58ad4d5aee..285a3116bd 100644
--- a/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationExecutionParameters.java
+++ b/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationExecutionParameters.java
@@ -6,18 +6,21 @@
 import graphql.collect.ImmutableKit;
 import graphql.execution.instrumentation.Instrumentation;
 import graphql.schema.GraphQLSchema;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.Map;
 
 /**
  * Parameters sent to {@link Instrumentation} methods
  */
+@NullMarked
 @PublicApi
 public class InstrumentationExecutionParameters {
     private final ExecutionInput executionInput;
     private final String query;
-    private final String operation;
-    private final Object context;
+    private final @Nullable String operation;
+    private final @Nullable Object context;
     private final GraphQLContext graphQLContext;
     private final Map<String, Object> variables;
     private final GraphQLSchema schema;
@@ -41,6 +44,7 @@ public String getQuery() {
         return query;
     }
 
+    @Nullable
     public String getOperation() {
         return operation;
     }
@@ -54,7 +58,7 @@ public String getOperation() {
      */
     @Deprecated(since = "2021-07-05")
     @SuppressWarnings({"unchecked", "TypeParameterUnusedInFormals"})
-    public <T> T getContext() {
+    public @Nullable <T> T getContext() {
         return (T) context;
     }
 
diff --git a/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationExecutionStrategyParameters.java b/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationExecutionStrategyParameters.java
index 9c93c84d42..f3503a0b32 100644
--- a/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationExecutionStrategyParameters.java
+++ b/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationExecutionStrategyParameters.java
@@ -3,10 +3,12 @@
 import graphql.PublicApi;
 import graphql.execution.ExecutionContext;
 import graphql.execution.ExecutionStrategyParameters;
+import org.jspecify.annotations.NullMarked;
 
 /**
  * Parameters sent to {@link graphql.execution.instrumentation.Instrumentation} methods
  */
+@NullMarked
 @PublicApi
 public class InstrumentationExecutionStrategyParameters {
 
diff --git a/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationFieldCompleteParameters.java b/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationFieldCompleteParameters.java
index ac7e1b27e5..2a49c12644 100644
--- a/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationFieldCompleteParameters.java
+++ b/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationFieldCompleteParameters.java
@@ -5,20 +5,25 @@
 import graphql.execution.ExecutionStepInfo;
 import graphql.execution.ExecutionStrategyParameters;
 import graphql.schema.GraphQLFieldDefinition;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.function.Supplier;
 
+import static graphql.Assert.assertNotNull;
+
 /**
  * Parameters sent to {@link graphql.execution.instrumentation.Instrumentation} methods
  */
+@NullMarked
 @PublicApi
 public class InstrumentationFieldCompleteParameters {
     private final ExecutionContext executionContext;
     private final Supplier<ExecutionStepInfo> executionStepInfo;
-    private final Object fetchedValue;
+    private final @Nullable Object fetchedValue;
     private final ExecutionStrategyParameters executionStrategyParameters;
 
-    public InstrumentationFieldCompleteParameters(ExecutionContext executionContext, ExecutionStrategyParameters executionStrategyParameters, Supplier<ExecutionStepInfo> executionStepInfo, Object fetchedValue) {
+    public InstrumentationFieldCompleteParameters(ExecutionContext executionContext, ExecutionStrategyParameters executionStrategyParameters, Supplier<ExecutionStepInfo> executionStepInfo, @Nullable Object fetchedValue) {
         this.executionContext = executionContext;
         this.executionStrategyParameters = executionStrategyParameters;
         this.executionStepInfo = executionStepInfo;
@@ -36,7 +41,7 @@ public ExecutionStrategyParameters getExecutionStrategyParameters() {
     }
 
     public GraphQLFieldDefinition getField() {
-        return getExecutionStepInfo().getFieldDefinition();
+        return assertNotNull(getExecutionStepInfo().getFieldDefinition(), "fieldDefinition must not be null");
     }
 
     @Deprecated(since = "2020-09-08")
@@ -54,6 +59,7 @@ public ExecutionStepInfo getExecutionStepInfo() {
      *
      * @return the object was fetched, ready to be completed as a value.
      */
+    @Nullable
     public Object getFetchedObject() {
         return fetchedValue;
     }
diff --git a/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationFieldFetchParameters.java b/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationFieldFetchParameters.java
index fda194d73e..5db11a737e 100644
--- a/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationFieldFetchParameters.java
+++ b/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationFieldFetchParameters.java
@@ -5,12 +5,14 @@
 import graphql.execution.ExecutionStrategyParameters;
 import graphql.execution.instrumentation.Instrumentation;
 import graphql.schema.DataFetchingEnvironment;
+import org.jspecify.annotations.NullMarked;
 
 import java.util.function.Supplier;
 
 /**
  * Parameters sent to {@link Instrumentation} methods
  */
+@NullMarked
 @PublicApi
 public class InstrumentationFieldFetchParameters extends InstrumentationFieldParameters {
     private final Supplier<DataFetchingEnvironment> environment;
diff --git a/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationFieldParameters.java b/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationFieldParameters.java
index ebac32ffb1..5b7fcd18f6 100644
--- a/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationFieldParameters.java
+++ b/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationFieldParameters.java
@@ -5,12 +5,16 @@
 import graphql.execution.ExecutionStepInfo;
 import graphql.execution.instrumentation.Instrumentation;
 import graphql.schema.GraphQLFieldDefinition;
+import org.jspecify.annotations.NullMarked;
 
 import java.util.function.Supplier;
 
+import static graphql.Assert.assertNotNull;
+
 /**
  * Parameters sent to {@link Instrumentation} methods
  */
+@NullMarked
 @PublicApi
 public class InstrumentationFieldParameters {
     private final ExecutionContext executionContext;
@@ -24,7 +28,7 @@ public ExecutionContext getExecutionContext() {
     }
 
     public GraphQLFieldDefinition getField() {
-        return executionStepInfo.get().getFieldDefinition();
+        return assertNotNull(executionStepInfo.get().getFieldDefinition(), "fieldDefinition must not be null");
     }
 
     public ExecutionStepInfo getExecutionStepInfo() {
diff --git a/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationValidationParameters.java b/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationValidationParameters.java
index c23a413941..21257df544 100644
--- a/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationValidationParameters.java
+++ b/src/main/java/graphql/execution/instrumentation/parameters/InstrumentationValidationParameters.java
@@ -5,10 +5,12 @@
 import graphql.execution.instrumentation.Instrumentation;
 import graphql.language.Document;
 import graphql.schema.GraphQLSchema;
+import org.jspecify.annotations.NullMarked;
 
 /**
  * Parameters sent to {@link Instrumentation} methods
  */
+@NullMarked
 @PublicApi
 public class InstrumentationValidationParameters extends InstrumentationExecutionParameters {
     private final Document document;
diff --git a/src/main/java/graphql/execution/instrumentation/tracing/TracingInstrumentation.java b/src/main/java/graphql/execution/instrumentation/tracing/TracingInstrumentation.java
index ed18f68ab8..f522ed1544 100644
--- a/src/main/java/graphql/execution/instrumentation/tracing/TracingInstrumentation.java
+++ b/src/main/java/graphql/execution/instrumentation/tracing/TracingInstrumentation.java
@@ -14,7 +14,7 @@
 import graphql.execution.instrumentation.parameters.InstrumentationValidationParameters;
 import graphql.language.Document;
 import graphql.validation.ValidationError;
-import org.jspecify.annotations.NonNull;
+import org.jspecify.annotations.NullMarked;
 import org.jspecify.annotations.Nullable;
 
 import java.util.LinkedHashMap;
@@ -29,6 +29,7 @@
  * This {@link Instrumentation} implementation uses {@link TracingSupport} to
  * capture tracing information and puts it into the {@link ExecutionResult}
  */
+@NullMarked
 @PublicApi
 public class TracingInstrumentation extends SimplePerformantInstrumentation {
 
@@ -77,7 +78,7 @@ public TracingInstrumentation(Options options) {
     }
 
     @Override
-    public @NonNull CompletableFuture<ExecutionResult> instrumentExecutionResult(ExecutionResult executionResult, InstrumentationExecutionParameters parameters, InstrumentationState rawState) {
+    public CompletableFuture<ExecutionResult> instrumentExecutionResult(ExecutionResult executionResult, InstrumentationExecutionParameters parameters, InstrumentationState rawState) {
         Map<Object, Object> currentExt = executionResult.getExtensions();
 
         TracingSupport tracingSupport = ofState(rawState);
diff --git a/src/main/java/graphql/execution/instrumentation/tracing/TracingSupport.java b/src/main/java/graphql/execution/instrumentation/tracing/TracingSupport.java
index 4a0f97a15c..0aa5a9a934 100644
--- a/src/main/java/graphql/execution/instrumentation/tracing/TracingSupport.java
+++ b/src/main/java/graphql/execution/instrumentation/tracing/TracingSupport.java
@@ -5,6 +5,7 @@
 import graphql.execution.ExecutionStepInfo;
 import graphql.execution.instrumentation.InstrumentationState;
 import graphql.schema.DataFetchingEnvironment;
+import org.jspecify.annotations.NullMarked;
 
 import java.time.Instant;
 import java.time.format.DateTimeFormatter;
@@ -13,6 +14,7 @@
 import java.util.Map;
 import java.util.concurrent.ConcurrentLinkedQueue;
 
+import static graphql.Assert.assertNotNull;
 import static graphql.schema.GraphQLTypeUtil.simplePrint;
 
 /**
@@ -22,6 +24,7 @@
  * calls.  It has been made a separate class so that you can compose this into existing
  * instrumentation code.
  */
+@NullMarked
 @PublicApi
 public class TracingSupport implements InstrumentationState {
 
@@ -78,9 +81,9 @@ public TracingContext beginField(DataFetchingEnvironment dataFetchingEnvironment
 
             Map<String, Object> fetchMap = new LinkedHashMap<>();
             fetchMap.put("path", executionStepInfo.getPath().toList());
-            fetchMap.put("parentType", simplePrint(executionStepInfo.getParent().getUnwrappedNonNullType()));
+            fetchMap.put("parentType", simplePrint(assertNotNull(executionStepInfo.getParent(), "executionStepInfo parent must not be null").getUnwrappedNonNullType()));
             fetchMap.put("returnType", executionStepInfo.simplePrint());
-            fetchMap.put("fieldName", executionStepInfo.getFieldDefinition().getName());
+            fetchMap.put("fieldName", assertNotNull(executionStepInfo.getFieldDefinition(), "fieldDefinition must not be null").getName());
             fetchMap.put("startOffset", startOffset);
             fetchMap.put("duration", duration);
 
diff --git a/src/main/java/graphql/execution/preparsed/PreparsedDocumentEntry.java b/src/main/java/graphql/execution/preparsed/PreparsedDocumentEntry.java
index 8c14cf9bf8..322c9978f7 100644
--- a/src/main/java/graphql/execution/preparsed/PreparsedDocumentEntry.java
+++ b/src/main/java/graphql/execution/preparsed/PreparsedDocumentEntry.java
@@ -3,8 +3,11 @@
 import graphql.GraphQLError;
 import graphql.PublicApi;
 import graphql.language.Document;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.io.Serializable;
+import java.util.Collections;
 import java.util.List;
 
 import static graphql.Assert.assertNotNull;
@@ -20,9 +23,10 @@
  * with times frames that cross graphql-java versions.  While we don't change things unnecessarily,  we may inadvertently break
  * the serialised compatibility across versions.
  */
+@NullMarked
 @PublicApi
 public class PreparsedDocumentEntry implements Serializable {
-    private final Document document;
+    private final @Nullable Document document;
     private final List<? extends GraphQLError> errors;
 
     public PreparsedDocumentEntry(Document document,
@@ -36,7 +40,7 @@ public PreparsedDocumentEntry(Document document,
     public PreparsedDocumentEntry(Document document) {
         assertNotNull(document);
         this.document = document;
-        this.errors = null;
+        this.errors = Collections.emptyList();
     }
 
     public PreparsedDocumentEntry(List<? extends GraphQLError> errors) {
@@ -49,6 +53,7 @@ public PreparsedDocumentEntry(GraphQLError error) {
         this(singletonList(assertNotNull(error)));
     }
 
+    @Nullable
     public Document getDocument() {
         return document;
     }
@@ -58,6 +63,6 @@ public List<? extends GraphQLError> getErrors() {
     }
 
     public boolean hasErrors() {
-        return errors != null && !errors.isEmpty();
+        return !errors.isEmpty();
     }
 }
diff --git a/src/main/java/graphql/execution/preparsed/persisted/ApolloPersistedQuerySupport.java b/src/main/java/graphql/execution/preparsed/persisted/ApolloPersistedQuerySupport.java
index b7b1a15302..68162bbc2a 100644
--- a/src/main/java/graphql/execution/preparsed/persisted/ApolloPersistedQuerySupport.java
+++ b/src/main/java/graphql/execution/preparsed/persisted/ApolloPersistedQuerySupport.java
@@ -2,6 +2,7 @@
 
 import graphql.ExecutionInput;
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
 
 import java.math.BigInteger;
 import java.nio.charset.StandardCharsets;
@@ -33,6 +34,7 @@
  *
  * @see graphql.ExecutionInput#getExtensions()
  */
+@NullMarked
 @PublicApi
 public class ApolloPersistedQuerySupport extends PersistedQuerySupport {
 
diff --git a/src/main/java/graphql/execution/preparsed/persisted/InMemoryPersistedQueryCache.java b/src/main/java/graphql/execution/preparsed/persisted/InMemoryPersistedQueryCache.java
index 5226332b85..18000e5090 100644
--- a/src/main/java/graphql/execution/preparsed/persisted/InMemoryPersistedQueryCache.java
+++ b/src/main/java/graphql/execution/preparsed/persisted/InMemoryPersistedQueryCache.java
@@ -4,6 +4,8 @@
 import graphql.ExecutionInput;
 import graphql.PublicApi;
 import graphql.execution.preparsed.PreparsedDocumentEntry;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
 
 import java.util.HashMap;
 import java.util.Map;
@@ -13,6 +15,7 @@
 /**
  * A PersistedQueryCache that is just an in memory map of known queries.
  */
+@NullMarked
 @PublicApi
 public class InMemoryPersistedQueryCache implements PersistedQueryCache {
 
@@ -53,6 +56,7 @@ public static Builder newInMemoryPersistedQueryCache() {
         return new Builder();
     }
 
+    @NullUnmarked
     public static class Builder {
         private final Map<Object, String> knownQueries = new HashMap<>();
 
diff --git a/src/main/java/graphql/execution/preparsed/persisted/PersistedQueryCacheMiss.java b/src/main/java/graphql/execution/preparsed/persisted/PersistedQueryCacheMiss.java
index 6e9cc03a3d..285c0c78a7 100644
--- a/src/main/java/graphql/execution/preparsed/persisted/PersistedQueryCacheMiss.java
+++ b/src/main/java/graphql/execution/preparsed/persisted/PersistedQueryCacheMiss.java
@@ -2,6 +2,7 @@
 
 import graphql.PublicApi;
 import graphql.execution.preparsed.PreparsedDocumentEntry;
+import org.jspecify.annotations.NullMarked;
 
 import java.util.function.Function;
 
@@ -10,6 +11,7 @@
  * by the graphql engine.  If you get a cache miss in your {@link graphql.execution.preparsed.persisted.PersistedQueryCache} implementation
  * then you are required to call back on the provided instance of this interface
  */
+@NullMarked
 @PublicApi
 public interface PersistedQueryCacheMiss extends Function<String, PreparsedDocumentEntry> {
     /**
diff --git a/src/main/java/graphql/execution/preparsed/persisted/PersistedQueryIdInvalid.java b/src/main/java/graphql/execution/preparsed/persisted/PersistedQueryIdInvalid.java
index 2599069797..120022ceb6 100644
--- a/src/main/java/graphql/execution/preparsed/persisted/PersistedQueryIdInvalid.java
+++ b/src/main/java/graphql/execution/preparsed/persisted/PersistedQueryIdInvalid.java
@@ -1,10 +1,12 @@
 package graphql.execution.preparsed.persisted;
 
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
 
 import java.util.LinkedHashMap;
 import java.util.Map;
 
+@NullMarked
 @PublicApi
 public class PersistedQueryIdInvalid extends PersistedQueryError {
     private final Object persistedQueryId;
diff --git a/src/main/java/graphql/execution/preparsed/persisted/PersistedQueryNotFound.java b/src/main/java/graphql/execution/preparsed/persisted/PersistedQueryNotFound.java
index 22c38bf8e5..14ff2968c1 100644
--- a/src/main/java/graphql/execution/preparsed/persisted/PersistedQueryNotFound.java
+++ b/src/main/java/graphql/execution/preparsed/persisted/PersistedQueryNotFound.java
@@ -1,6 +1,7 @@
 package graphql.execution.preparsed.persisted;
 
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
 
 import java.util.LinkedHashMap;
 import java.util.Map;
@@ -8,6 +9,7 @@
 /**
  * An exception that indicates the query id is not valid and can be found ever in cache
  */
+@NullMarked
 @PublicApi
 public class PersistedQueryNotFound extends PersistedQueryError {
     private final Object persistedQueryId;
diff --git a/src/main/java/graphql/execution/reactive/CompletionStageOrderedSubscriber.java b/src/main/java/graphql/execution/reactive/CompletionStageOrderedSubscriber.java
index 53a8dd4719..54efa9c04d 100644
--- a/src/main/java/graphql/execution/reactive/CompletionStageOrderedSubscriber.java
+++ b/src/main/java/graphql/execution/reactive/CompletionStageOrderedSubscriber.java
@@ -32,8 +32,7 @@ protected void whenNextFinished(CompletionStage<D> completionStage, D d, Throwab
                 emptyInFlightQueueIfWeCan();
             }
         } finally {
-            boolean empty = inFlightQIsEmpty();
-            finallyAfterEachPromiseFinishes(empty);
+            finallyAfterEachPromiseFinishes();
         }
     }
 
diff --git a/src/main/java/graphql/execution/reactive/CompletionStageSubscriber.java b/src/main/java/graphql/execution/reactive/CompletionStageSubscriber.java
index b185ce9bba..45888d384f 100644
--- a/src/main/java/graphql/execution/reactive/CompletionStageSubscriber.java
+++ b/src/main/java/graphql/execution/reactive/CompletionStageSubscriber.java
@@ -95,20 +95,19 @@ protected void whenNextFinished(CompletionStage<D> completionStage, D d, Throwab
                 downstreamSubscriber.onNext(d);
             }
         } finally {
-            boolean empty = removeFromInFlightQAndCheckIfEmpty(completionStage);
-            finallyAfterEachPromiseFinishes(empty);
+            removeFromInFlightQ(completionStage);
+            finallyAfterEachPromiseFinishes();
         }
     }
 
-    protected void finallyAfterEachPromiseFinishes(boolean isInFlightEmpty) {
-        //
-        // if the runOnCompleteOrErrorRun runnable is set, the upstream has
-        // called onComplete() already, but the CFs have not all completed
-        // yet, so we have to check whenever a CF completes
-        //
-        Runnable runOnCompleteOrErrorRun = onCompleteRun.get();
-        if (isInFlightEmpty && runOnCompleteOrErrorRun != null) {
-            onCompleteRun.set(null);
+    protected void finallyAfterEachPromiseFinishes() {
+        Runnable runOnCompleteOrErrorRun = lock.callLocked(() -> {
+            if (inFlightDataQ.isEmpty()) {
+                return onCompleteRun.getAndSet(null);
+            }
+            return null;
+        });
+        if (runOnCompleteOrErrorRun != null) {
             runOnCompleteOrErrorRun.run();
         }
     }
@@ -149,11 +148,15 @@ public void onComplete() {
     }
 
     private void onComplete(Runnable doneCodeToRun) {
-        if (inFlightQIsEmpty()) {
-            // run right now
-            doneCodeToRun.run();
-        } else {
+        boolean runNow = lock.callLocked(() -> {
+            if (inFlightDataQ.isEmpty()) {
+                return true;
+            }
             onCompleteRun.set(doneCodeToRun);
+            return false;
+        });
+        if (runNow) {
+            doneCodeToRun.run();
         }
     }
 
@@ -163,12 +166,8 @@ protected void offerToInFlightQ(CompletionStage<?> completionStage) {
         );
     }
 
-    private boolean removeFromInFlightQAndCheckIfEmpty(CompletionStage<?> completionStage) {
-        // uncontested locks in java are cheap - we don't expect much contention here
-        return lock.callLocked(() -> {
-            inFlightDataQ.remove(completionStage);
-            return inFlightDataQ.isEmpty();
-        });
+    private void removeFromInFlightQ(CompletionStage<?> completionStage) {
+        lock.runLocked(() -> inFlightDataQ.remove(completionStage));
     }
 
     /**
@@ -186,10 +185,6 @@ private void cancelInFlightFutures() {
         });
     }
 
-    protected boolean inFlightQIsEmpty() {
-        return lock.callLocked(inFlightDataQ::isEmpty);
-    }
-
     /**
      * The two terminal states are onComplete or onError
      *
diff --git a/src/main/java/graphql/execution/reactive/DelegatingSubscription.java b/src/main/java/graphql/execution/reactive/DelegatingSubscription.java
index e8a3ff9df3..3f51f690c2 100644
--- a/src/main/java/graphql/execution/reactive/DelegatingSubscription.java
+++ b/src/main/java/graphql/execution/reactive/DelegatingSubscription.java
@@ -1,6 +1,7 @@
 package graphql.execution.reactive;
 
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
 import org.reactivestreams.Subscription;
 
 import static graphql.Assert.assertNotNull;
@@ -8,6 +9,7 @@
 /**
  * A simple subscription that delegates to another
  */
+@NullMarked
 @PublicApi
 public class DelegatingSubscription implements Subscription {
     private final Subscription upstreamSubscription;
diff --git a/src/main/java/graphql/execution/reactive/SubscriptionPublisher.java b/src/main/java/graphql/execution/reactive/SubscriptionPublisher.java
index 4951b451df..e3fbf5bd96 100644
--- a/src/main/java/graphql/execution/reactive/SubscriptionPublisher.java
+++ b/src/main/java/graphql/execution/reactive/SubscriptionPublisher.java
@@ -3,6 +3,7 @@
 import graphql.ExecutionResult;
 import graphql.Internal;
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
 import org.reactivestreams.Publisher;
 import org.reactivestreams.Subscriber;
 
@@ -21,6 +22,7 @@
  * }
  * </pre>
  */
+@NullMarked
 @SuppressWarnings("ReactiveStreamsPublisherImplementation")
 @PublicApi
 public class SubscriptionPublisher implements Publisher<ExecutionResult> {
diff --git a/src/main/java/graphql/introspection/GoodFaithIntrospection.java b/src/main/java/graphql/introspection/GoodFaithIntrospection.java
index ae7da12569..2d40425cee 100644
--- a/src/main/java/graphql/introspection/GoodFaithIntrospection.java
+++ b/src/main/java/graphql/introspection/GoodFaithIntrospection.java
@@ -1,31 +1,19 @@
 package graphql.introspection;
 
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.ImmutableListMultimap;
 import graphql.ErrorClassification;
-import graphql.ExecutionResult;
 import graphql.GraphQLContext;
 import graphql.GraphQLError;
 import graphql.PublicApi;
-import graphql.execution.AbortExecutionException;
-import graphql.execution.ExecutionContext;
 import graphql.language.SourceLocation;
-import graphql.normalized.ExecutableNormalizedField;
-import graphql.normalized.ExecutableNormalizedOperation;
-import graphql.schema.FieldCoordinates;
+import graphql.validation.QueryComplexityLimits;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.List;
-import java.util.Map;
-import java.util.Optional;
 import java.util.concurrent.atomic.AtomicBoolean;
 
-import static graphql.normalized.ExecutableNormalizedOperationFactory.Options;
-import static graphql.normalized.ExecutableNormalizedOperationFactory.createExecutableNormalizedOperation;
-import static graphql.schema.FieldCoordinates.coordinates;
-
 /**
- * This {@link graphql.execution.instrumentation.Instrumentation} ensure that a submitted introspection query is done in
- * good faith.
+ * Good Faith Introspection ensures that introspection queries are not abused to cause denial of service.
  * <p>
  * There are attack vectors where a crafted introspection query can cause the engine to spend too much time
  * producing introspection data.  This is especially true on large schemas with lots of types and fields.
@@ -33,11 +21,18 @@
  * Schemas form a cyclic graph and hence it's possible to send in introspection queries that can reference those cycles
  * and in large schemas this can be expensive and perhaps a "denial of service".
  * <p>
- * This instrumentation only allows one __schema field or one __type field to be present, and it does not allow the `__Type` fields
- * to form a cycle, i.e., that can only be present once.  This allows the standard and common introspection queries to work
- * so tooling such as graphiql can work.
+ * When enabled, the validation layer enforces that:
+ * <ul>
+ * <li>Only one {@code __schema} and one {@code __type} field can appear per operation</li>
+ * <li>The {@code __Type} fields {@code fields}, {@code inputFields}, {@code interfaces}, and {@code possibleTypes}
+ * can each only appear once (preventing cyclic traversals)</li>
+ * <li>The query complexity is limited to {@link #GOOD_FAITH_MAX_FIELDS_COUNT} fields and
+ * {@link #GOOD_FAITH_MAX_DEPTH_COUNT} depth</li>
+ * </ul>
+ * This allows the standard and common introspection queries to work so tooling such as graphiql can work.
  */
 @PublicApi
+@NullMarked
 public class GoodFaithIntrospection {
 
     /**
@@ -74,67 +69,36 @@ public static boolean enabledJvmWide(boolean flag) {
         return ENABLED_STATE.getAndSet(flag);
     }
 
-    private static final Map<FieldCoordinates, Integer> ALLOWED_FIELD_INSTANCES = Map.of(
-            coordinates("Query", "__schema"), 1
-            , coordinates("Query", "__type"), 1
-
-            , coordinates("__Type", "fields"), 1
-            , coordinates("__Type", "inputFields"), 1
-            , coordinates("__Type", "interfaces"), 1
-            , coordinates("__Type", "possibleTypes"), 1
-    );
-
-    public static Optional<ExecutionResult> checkIntrospection(ExecutionContext executionContext) {
-        if (isIntrospectionEnabled(executionContext.getGraphQLContext())) {
-            ExecutableNormalizedOperation operation;
-            try {
-                operation = mkOperation(executionContext);
-            } catch (AbortExecutionException e) {
-                BadFaithIntrospectionError error = BadFaithIntrospectionError.tooBigOperation(e.getMessage());
-                return Optional.of(ExecutionResult.newExecutionResult().addError(error).build());
-            }
-            ImmutableListMultimap<FieldCoordinates, ExecutableNormalizedField> coordinatesToENFs = operation.getCoordinatesToNormalizedFields();
-            for (Map.Entry<FieldCoordinates, Integer> entry : ALLOWED_FIELD_INSTANCES.entrySet()) {
-                FieldCoordinates coordinates = entry.getKey();
-                Integer allowSize = entry.getValue();
-                ImmutableList<ExecutableNormalizedField> normalizedFields = coordinatesToENFs.get(coordinates);
-                if (normalizedFields.size() > allowSize) {
-                    BadFaithIntrospectionError error = BadFaithIntrospectionError.tooManyFields(coordinates.toString());
-                    return Optional.of(ExecutionResult.newExecutionResult().addError(error).build());
-                }
-            }
-        }
-        return Optional.empty();
-    }
-
     /**
-     * This makes an executable operation limited in size then which suits a good faith introspection query.  This helps guard
-     * against malicious queries.
+     * Checks whether Good Faith Introspection is enabled for the given request context.
      *
-     * @param executionContext the execution context
+     * @param graphQLContext the per-request context
      *
-     * @return an executable operation
+     * @return true if good faith introspection checks should be applied
      */
-    private static ExecutableNormalizedOperation mkOperation(ExecutionContext executionContext) throws AbortExecutionException {
-        Options options = Options.defaultOptions()
-                .maxFieldsCount(GOOD_FAITH_MAX_FIELDS_COUNT)
-                .maxChildrenDepth(GOOD_FAITH_MAX_DEPTH_COUNT)
-                .locale(executionContext.getLocale())
-                .graphQLContext(executionContext.getGraphQLContext());
-
-        return createExecutableNormalizedOperation(executionContext.getGraphQLSchema(),
-                executionContext.getOperationDefinition(),
-                executionContext.getFragmentsByName(),
-                executionContext.getCoercedVariables(),
-                options);
-
-    }
-
-    private static boolean isIntrospectionEnabled(GraphQLContext graphQlContext) {
+    public static boolean isEnabled(GraphQLContext graphQLContext) {
         if (!isEnabledJvmWide()) {
             return false;
         }
-        return !graphQlContext.getBoolean(GOOD_FAITH_INTROSPECTION_DISABLED, false);
+        return !graphQLContext.getBoolean(GOOD_FAITH_INTROSPECTION_DISABLED, false);
+    }
+
+    /**
+     * Returns query complexity limits that are the minimum of the existing limits and the
+     * good faith introspection limits. This ensures introspection queries are bounded
+     * without overriding tighter user-specified limits.
+     *
+     * @param existing the existing complexity limits (may be null, in which case defaults are used)
+     *
+     * @return complexity limits with good faith bounds applied
+     */
+    public static QueryComplexityLimits goodFaithLimits(QueryComplexityLimits existing) {
+        int maxFields = Math.min(existing.getMaxFieldsCount(), GOOD_FAITH_MAX_FIELDS_COUNT);
+        int maxDepth = Math.min(existing.getMaxDepth(), GOOD_FAITH_MAX_DEPTH_COUNT);
+        return QueryComplexityLimits.newLimits()
+                .maxFieldsCount(maxFields)
+                .maxDepth(maxDepth)
+                .build();
     }
 
     public static class BadFaithIntrospectionError implements GraphQLError {
@@ -163,7 +127,7 @@ public ErrorClassification getErrorType() {
         }
 
         @Override
-        public List<SourceLocation> getLocations() {
+        public @Nullable List<SourceLocation> getLocations() {
             return null;
         }
 
diff --git a/src/main/java/graphql/introspection/Introspection.java b/src/main/java/graphql/introspection/Introspection.java
index a455ec9d78..e8c7173e68 100644
--- a/src/main/java/graphql/introspection/Introspection.java
+++ b/src/main/java/graphql/introspection/Introspection.java
@@ -116,7 +116,6 @@ public static boolean isEnabledJvmWide() {
     public static Optional<ExecutionResult> isIntrospectionSensible(MergedSelectionSet mergedSelectionSet, ExecutionContext executionContext) {
         GraphQLContext graphQLContext = executionContext.getGraphQLContext();
 
-        boolean isIntrospection = false;
         for (String key : mergedSelectionSet.getKeys()) {
             String fieldName = mergedSelectionSet.getSubField(key).getName();
             if (fieldName.equals(SchemaMetaFieldDef.getName())
@@ -124,13 +123,9 @@ public static Optional<ExecutionResult> isIntrospectionSensible(MergedSelectionS
                 if (!isIntrospectionEnabled(graphQLContext)) {
                     return mkDisabledError(mergedSelectionSet.getSubField(key));
                 }
-                isIntrospection = true;
                 break;
             }
         }
-        if (isIntrospection) {
-            return GoodFaithIntrospection.checkIntrospection(executionContext);
-        }
         return Optional.empty();
     }
 
diff --git a/src/main/java/graphql/language/AbstractDescribedNode.java b/src/main/java/graphql/language/AbstractDescribedNode.java
index af963e7ab5..6cb83dc0a7 100644
--- a/src/main/java/graphql/language/AbstractDescribedNode.java
+++ b/src/main/java/graphql/language/AbstractDescribedNode.java
@@ -1,22 +1,25 @@
 package graphql.language;
 
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.List;
 import java.util.Map;
 
 @PublicApi
+@NullMarked
 public abstract class AbstractDescribedNode<T extends Node> extends AbstractNode<T> implements DescribedNode<T>  {
 
-    protected Description description;
+    protected @Nullable Description description;
 
-    public AbstractDescribedNode(SourceLocation sourceLocation, List<Comment> comments, IgnoredChars ignoredChars, Map<String, String> additionalData, Description description) {
+    public AbstractDescribedNode(@Nullable SourceLocation sourceLocation, List<Comment> comments, IgnoredChars ignoredChars, Map<String, String> additionalData, @Nullable Description description) {
         super(sourceLocation, comments, ignoredChars, additionalData);
         this.description = description;
     }
 
     @Override
-    public Description getDescription() {
+    public @Nullable Description getDescription() {
         return description;
     }
 }
diff --git a/src/main/java/graphql/language/AstNodeAdapter.java b/src/main/java/graphql/language/AstNodeAdapter.java
index 304fdfb5e9..31e3b3dd90 100644
--- a/src/main/java/graphql/language/AstNodeAdapter.java
+++ b/src/main/java/graphql/language/AstNodeAdapter.java
@@ -3,6 +3,7 @@
 import graphql.PublicApi;
 import graphql.util.NodeAdapter;
 import graphql.util.NodeLocation;
+import org.jspecify.annotations.NullMarked;
 
 import java.util.List;
 import java.util.Map;
@@ -11,6 +12,7 @@
  * Adapts an Ast node to the general node from the util package
  */
 @PublicApi
+@NullMarked
 public class AstNodeAdapter implements NodeAdapter<Node> {
 
     public static final AstNodeAdapter AST_NODE_ADAPTER = new AstNodeAdapter();
diff --git a/src/main/java/graphql/language/AstPrinter.java b/src/main/java/graphql/language/AstPrinter.java
index a5e1535ea5..4fb52737f3 100644
--- a/src/main/java/graphql/language/AstPrinter.java
+++ b/src/main/java/graphql/language/AstPrinter.java
@@ -2,6 +2,8 @@
 
 import graphql.PublicApi;
 import graphql.collect.ImmutableKit;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.io.IOException;
 import java.io.UncheckedIOException;
@@ -20,6 +22,7 @@
  */
 @SuppressWarnings("UnnecessaryLocalVariable")
 @PublicApi
+@NullMarked
 public class AstPrinter {
 
     /**
@@ -368,7 +371,8 @@ private NodePrinter<OperationDefinition> operationDefinition() {
                     && node.getOperation() == OperationDefinition.Operation.QUERY) {
                 node(out, node.getSelectionSet());
             } else {
-                out.append(node.getOperation().toString().toLowerCase());
+                OperationDefinition.Operation op = node.getOperation();
+                out.append(op.toString().toLowerCase());
                 if (!isEmpty(name)) {
                     out.append(' ');
                     out.append(name);
@@ -566,13 +570,13 @@ private void node(StringBuilder out, Node<?> node) {
         node(out, node, null);
     }
 
-    private String node(Node<?> node, Class<?> startClass) {
+    private String node(Node<?> node, @Nullable Class<?> startClass) {
         StringBuilder builder = new StringBuilder();
         node(builder, node, startClass);
         return builder.toString();
     }
 
-    private void node(StringBuilder out, Node<?> node, Class<?> startClass) {
+    private void node(StringBuilder out, Node<?> node, @Nullable Class<?> startClass) {
         if (startClass != null) {
             assertTrue(startClass.isInstance(node), "The starting class must be in the inherit tree");
         }
@@ -585,16 +589,12 @@ <T extends Node> NodePrinter<T> _findPrinter(Node node) {
         return _findPrinter(node, null);
     }
 
-    <T extends Node> NodePrinter<T> _findPrinter(Node node, Class startClass) {
-        if (node == null) {
-            return (out, type) -> {
-            };
-        }
+    <T extends Node> NodePrinter<T> _findPrinter(Node node, @Nullable Class<?> startClass) {
         Class<?> clazz = startClass != null ? startClass : node.getClass();
         while (clazz != Object.class) {
             NodePrinter nodePrinter = printers.get(clazz);
             if (nodePrinter != null) {
-                //noinspection unchecked
+                // noinspection unchecked
                 return nodePrinter;
             }
             clazz = clazz.getSuperclass();
@@ -602,15 +602,15 @@ <T extends Node> NodePrinter<T> _findPrinter(Node node, Class startClass) {
         return assertShouldNeverHappen("We have a missing printer implementation for %s : report a bug!", clazz);
     }
 
-    private static <T> boolean isEmpty(List<T> list) {
+    private static <T> boolean isEmpty(@Nullable List<T> list) {
         return list == null || list.isEmpty();
     }
 
-    private static boolean isEmpty(String s) {
+    private static boolean isEmpty(@Nullable String s) {
         return s == null || s.isBlank();
     }
 
-    private static <T> List<T> nvl(List<T> list) {
+    private static <T> List<T> nvl(@Nullable List<T> list) {
         return list != null ? list : ImmutableKit.emptyList();
     }
 
@@ -745,7 +745,7 @@ private static void indent(StringBuilder maybeString, int offset) {
     }
 
     @SuppressWarnings("SameParameterValue")
-    String wrap(String start, Node maybeNode, String end) {
+    String wrap(String start, @Nullable Node maybeNode, String end) {
         if (maybeNode == null) {
             return "";
         }
diff --git a/src/main/java/graphql/language/AstSignature.java b/src/main/java/graphql/language/AstSignature.java
index f6964305b2..9348f1435c 100644
--- a/src/main/java/graphql/language/AstSignature.java
+++ b/src/main/java/graphql/language/AstSignature.java
@@ -4,6 +4,8 @@
 import graphql.collect.ImmutableKit;
 import graphql.util.TraversalControl;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.math.BigDecimal;
 import java.math.BigInteger;
@@ -18,6 +20,7 @@
  * This will produce signature and privacy safe query documents that can be used for query categorisation and logging.
  */
 @PublicApi
+@NullMarked
 public class AstSignature {
 
     /**
@@ -34,7 +37,7 @@ public class AstSignature {
      *
      * @return the signature query in document form
      */
-    public Document signatureQuery(Document document, String operationName) {
+    public Document signatureQuery(Document document, @Nullable String operationName) {
         return sortAST(
                 removeAliases(
                         hideLiterals(true,
@@ -57,7 +60,7 @@ public Document signatureQuery(Document document, String operationName) {
      *
      * @return the privacy safe query in document form
      */
-    public Document privacySafeQuery(Document document, String operationName) {
+    public Document privacySafeQuery(Document document, @Nullable String operationName) {
         return sortAST(
                 removeAliases(
                         hideLiterals(false,
@@ -144,7 +147,7 @@ private Document sortAST(Document document) {
         return new AstSorter().sort(document);
     }
 
-    private Document dropUnusedQueryDefinitions(Document document, final String operationName) {
+    private Document dropUnusedQueryDefinitions(Document document, final @Nullable String operationName) {
         NodeVisitorStub visitor = new NodeVisitorStub() {
             @Override
             public TraversalControl visitDocument(Document node, TraverserContext<Node> context) {
@@ -167,7 +170,7 @@ public TraversalControl visitDocument(Document node, TraverserContext<Node> cont
         return transformDoc(document, visitor);
     }
 
-    private boolean isThisOperation(OperationDefinition operationDefinition, String operationName) {
+    private boolean isThisOperation(OperationDefinition operationDefinition, @Nullable String operationName) {
         String name = operationDefinition.getName();
         if (operationName == null) {
             return name == null;
diff --git a/src/main/java/graphql/language/AstSorter.java b/src/main/java/graphql/language/AstSorter.java
index d24969ea94..48a4b7efec 100644
--- a/src/main/java/graphql/language/AstSorter.java
+++ b/src/main/java/graphql/language/AstSorter.java
@@ -4,6 +4,8 @@
 import graphql.schema.idl.TypeInfo;
 import graphql.util.TraversalControl;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.Comparator;
@@ -18,6 +20,7 @@
  * A class that helps you sort AST nodes
  */
 @PublicApi
+@NullMarked
 public class AstSorter {
 
     /**
@@ -281,7 +284,7 @@ private Comparator<Definition> comparingDefinitions() {
         Function<Definition, Integer> byType = d -> {
             if (d instanceof OperationDefinition) {
                 OperationDefinition.Operation operation = ((OperationDefinition) d).getOperation();
-                if (OperationDefinition.Operation.QUERY == operation || operation == null) {
+                if (OperationDefinition.Operation.QUERY == operation) {
                     return 101;
                 }
                 if (OperationDefinition.Operation.MUTATION == operation) {
@@ -328,7 +331,7 @@ private Comparator<Definition> comparingDefinitions() {
         return comparing(byType).thenComparing(byName);
     }
 
-    private SelectionSet sortSelectionSet(SelectionSet selectionSet) {
+    private @Nullable SelectionSet sortSelectionSet(@Nullable SelectionSet selectionSet) {
         if (selectionSet == null) {
             return null;
         }
diff --git a/src/main/java/graphql/language/AstTransformer.java b/src/main/java/graphql/language/AstTransformer.java
index f4e218dffd..b2d48acd1a 100644
--- a/src/main/java/graphql/language/AstTransformer.java
+++ b/src/main/java/graphql/language/AstTransformer.java
@@ -7,6 +7,8 @@
 import graphql.util.TraverserVisitorStub;
 import graphql.util.TreeParallelTransformer;
 import graphql.util.TreeTransformer;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.Map;
 import java.util.concurrent.ForkJoinPool;
@@ -19,6 +21,7 @@
  * containing the changed nodes while everything else is the same.
  */
 @PublicApi
+@NullMarked
 public class AstTransformer {
 
     /**
@@ -46,7 +49,7 @@ public Node transform(Node root, NodeVisitor nodeVisitor) {
      *                 can be retrieved within the visitor by calling context.getVarFromParents().
      * @return the transformed tree.
      */
-    public Node transform(Node root, NodeVisitor nodeVisitor, Map<Class<?>, Object> rootVars) {
+    public Node transform(Node root, NodeVisitor nodeVisitor, @Nullable Map<Class<?>, Object> rootVars) {
         assertNotNull(root);
         assertNotNull(nodeVisitor);
 
diff --git a/src/main/java/graphql/language/Comment.java b/src/main/java/graphql/language/Comment.java
index a7a546facf..65096c6782 100644
--- a/src/main/java/graphql/language/Comment.java
+++ b/src/main/java/graphql/language/Comment.java
@@ -1,6 +1,8 @@
 package graphql.language;
 
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.io.Serializable;
 
@@ -8,11 +10,12 @@
  * A single-line comment. These are comments that start with a {@code #} in source documents.
  */
 @PublicApi
+@NullMarked
 public class Comment implements Serializable {
     public final String content;
-    public final SourceLocation sourceLocation;
+    public final @Nullable SourceLocation sourceLocation;
 
-    public Comment(String content, SourceLocation sourceLocation) {
+    public Comment(String content, @Nullable SourceLocation sourceLocation) {
         this.content = content;
         this.sourceLocation = sourceLocation;
     }
@@ -21,7 +24,7 @@ public String getContent() {
         return content;
     }
 
-    public SourceLocation getSourceLocation() {
+    public @Nullable SourceLocation getSourceLocation() {
         return sourceLocation;
     }
 }
diff --git a/src/main/java/graphql/language/Definition.java b/src/main/java/graphql/language/Definition.java
index f0e7d74dc9..5402bfe3c6 100644
--- a/src/main/java/graphql/language/Definition.java
+++ b/src/main/java/graphql/language/Definition.java
@@ -2,8 +2,10 @@
 
 
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
 
 @PublicApi
+@NullMarked
 public interface Definition<T extends Definition> extends Node<T> {
 
 }
diff --git a/src/main/java/graphql/language/DescribedNode.java b/src/main/java/graphql/language/DescribedNode.java
index 0d68dac601..28773d63a6 100644
--- a/src/main/java/graphql/language/DescribedNode.java
+++ b/src/main/java/graphql/language/DescribedNode.java
@@ -1,16 +1,19 @@
 package graphql.language;
 
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 /**
  * Represents a node that can contain a description.
  */
 @PublicApi
+@NullMarked
 public interface DescribedNode<T extends Node> extends Node<T> {
 
     /**
      * @return the description of this node
      */
-    Description getDescription();
+    @Nullable Description getDescription();
 
 }
diff --git a/src/main/java/graphql/language/Description.java b/src/main/java/graphql/language/Description.java
index 3b86e47ac9..e0f83eb034 100644
--- a/src/main/java/graphql/language/Description.java
+++ b/src/main/java/graphql/language/Description.java
@@ -1,16 +1,19 @@
 package graphql.language;
 
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.io.Serializable;
 
 @PublicApi
+@NullMarked
 public class Description implements Serializable {
     public final String content;
-    public final SourceLocation sourceLocation;
+    public final @Nullable SourceLocation sourceLocation;
     public final boolean multiLine;
 
-    public Description(String content, SourceLocation sourceLocation, boolean multiLine) {
+    public Description(String content, @Nullable SourceLocation sourceLocation, boolean multiLine) {
         this.content = content;
         this.sourceLocation = sourceLocation;
         this.multiLine = multiLine;
@@ -20,7 +23,7 @@ public String getContent() {
         return content;
     }
 
-    public SourceLocation getSourceLocation() {
+    public @Nullable SourceLocation getSourceLocation() {
         return sourceLocation;
     }
 
diff --git a/src/main/java/graphql/language/Directive.java b/src/main/java/graphql/language/Directive.java
index 999722bec7..ceaa47c650 100644
--- a/src/main/java/graphql/language/Directive.java
+++ b/src/main/java/graphql/language/Directive.java
@@ -7,6 +7,9 @@
 import graphql.collect.ImmutableKit;
 import graphql.util.TraversalControl;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -21,6 +24,7 @@
 import static graphql.language.NodeUtil.nodeByName;
 
 @PublicApi
+@NullMarked
 public class Directive extends AbstractNode<Directive> implements NamedNode<Directive> {
     private final String name;
     private final ImmutableList<Argument> arguments;
@@ -28,7 +32,7 @@ public class Directive extends AbstractNode<Directive> implements NamedNode<Dire
     public static final String CHILD_ARGUMENTS = "arguments";
 
     @Internal
-    protected Directive(String name, List<Argument> arguments, SourceLocation sourceLocation, List<Comment> comments, IgnoredChars ignoredChars, Map<String, String> additionalData) {
+    protected Directive(String name, List<Argument> arguments, @Nullable SourceLocation sourceLocation, List<Comment> comments, IgnoredChars ignoredChars, Map<String, String> additionalData) {
         super(sourceLocation, comments, ignoredChars, additionalData);
         this.name = name;
         this.arguments = ImmutableList.copyOf(arguments);
@@ -63,7 +67,7 @@ public Map<String, Argument> getArgumentsByName() {
         return nodeByName(arguments);
     }
 
-    public Argument getArgument(String argumentName) {
+    public @Nullable Argument getArgument(String argumentName) {
         return NodeUtil.findNodeByName(arguments, argumentName);
     }
 
@@ -93,7 +97,7 @@ public Directive withNewChildren(NodeChildrenContainer newChildren) {
     }
 
     @Override
-    public boolean isEqualTo(Node o) {
+    public boolean isEqualTo(@Nullable Node o) {
         if (this == o) {
             return true;
         }
@@ -109,7 +113,7 @@ public boolean isEqualTo(Node o) {
 
     @Override
     public Directive deepCopy() {
-        return new Directive(name, deepCopy(arguments), getSourceLocation(), getComments(), getIgnoredChars(), getAdditionalData());
+        return new Directive(name, assertNotNull(deepCopy(arguments), "arguments cannot be null"), getSourceLocation(), getComments(), getIgnoredChars(), getAdditionalData());
     }
 
     @Override
@@ -135,6 +139,7 @@ public Directive transform(Consumer<Builder> builderConsumer) {
         return builder.build();
     }
 
+    @NullUnmarked
     public static final class Builder implements NodeBuilder {
         private SourceLocation sourceLocation;
         private ImmutableList<Comment> comments = emptyList();
diff --git a/src/main/java/graphql/language/DirectiveDefinition.java b/src/main/java/graphql/language/DirectiveDefinition.java
index 8aed5bb9ff..0d9d39da9d 100644
--- a/src/main/java/graphql/language/DirectiveDefinition.java
+++ b/src/main/java/graphql/language/DirectiveDefinition.java
@@ -7,6 +7,9 @@
 import graphql.collect.ImmutableKit;
 import graphql.util.TraversalControl;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
@@ -21,6 +24,7 @@
 import static graphql.language.NodeChildrenContainer.newNodeChildrenContainer;
 
 @PublicApi
+@NullMarked
 public class DirectiveDefinition extends AbstractDescribedNode<DirectiveDefinition> implements SDLNamedDefinition<DirectiveDefinition>, NamedNode<DirectiveDefinition> {
     private final String name;
     private final boolean repeatable;
@@ -33,10 +37,10 @@ public class DirectiveDefinition extends AbstractDescribedNode<DirectiveDefiniti
     @Internal
     protected DirectiveDefinition(String name,
                                   boolean repeatable,
-                                  Description description,
+                                  @Nullable Description description,
                                   List<InputValueDefinition> inputValueDefinitions,
                                   List<DirectiveLocation> directiveLocations,
-                                  SourceLocation sourceLocation,
+                                  @Nullable SourceLocation sourceLocation,
                                   List<Comment> comments,
                                   IgnoredChars ignoredChars,
                                   Map<String, String> additionalData) {
@@ -104,7 +108,7 @@ public DirectiveDefinition withNewChildren(NodeChildrenContainer newChildren) {
     }
 
     @Override
-    public boolean isEqualTo(Node o) {
+    public boolean isEqualTo(@Nullable Node o) {
         if (this == o) {
             return true;
         }
@@ -122,8 +126,8 @@ public DirectiveDefinition deepCopy() {
         return new DirectiveDefinition(name,
                 repeatable,
                 description,
-                deepCopy(inputValueDefinitions),
-                deepCopy(directiveLocations),
+                assertNotNull(deepCopy(inputValueDefinitions), "inputValueDefinitions cannot be null"),
+                assertNotNull(deepCopy(directiveLocations), "directiveLocations cannot be null"),
                 getSourceLocation(),
                 getComments(),
                 getIgnoredChars(),
@@ -154,6 +158,7 @@ public DirectiveDefinition transform(Consumer<Builder> builderConsumer) {
         return builder.build();
     }
 
+    @NullUnmarked
     public static final class Builder implements NodeBuilder {
         private SourceLocation sourceLocation;
         private ImmutableList<Comment> comments = emptyList();
diff --git a/src/main/java/graphql/language/DirectiveLocation.java b/src/main/java/graphql/language/DirectiveLocation.java
index f9e5d920d0..841807330e 100644
--- a/src/main/java/graphql/language/DirectiveLocation.java
+++ b/src/main/java/graphql/language/DirectiveLocation.java
@@ -6,6 +6,9 @@
 import graphql.PublicApi;
 import graphql.util.TraversalControl;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -20,11 +23,12 @@
 import static graphql.language.NodeUtil.assertNewChildrenAreEmpty;
 
 @PublicApi
+@NullMarked
 public class DirectiveLocation extends AbstractNode<DirectiveLocation> implements NamedNode<DirectiveLocation> {
     private final String name;
 
     @Internal
-    protected DirectiveLocation(String name, SourceLocation sourceLocation, List<Comment> comments, IgnoredChars ignoredChars, Map<String, String> additionalData) {
+    protected DirectiveLocation(String name, @Nullable SourceLocation sourceLocation, List<Comment> comments, IgnoredChars ignoredChars, Map<String, String> additionalData) {
         super(sourceLocation, comments, ignoredChars, additionalData);
         this.name = name;
     }
@@ -60,7 +64,7 @@ public DirectiveLocation withNewChildren(NodeChildrenContainer newChildren) {
     }
 
     @Override
-    public boolean isEqualTo(Node o) {
+    public boolean isEqualTo(@Nullable Node o) {
         if (this == o) {
             return true;
         }
@@ -100,6 +104,7 @@ public DirectiveLocation transform(Consumer<Builder> builderConsumer) {
         return builder.build();
     }
 
+    @NullUnmarked
     public static final class Builder implements NodeBuilder {
         private SourceLocation sourceLocation;
         private ImmutableList<Comment> comments = emptyList();
@@ -148,7 +153,7 @@ public Builder additionalData(String key, String value) {
         }
 
         public DirectiveLocation build() {
-            return new DirectiveLocation(name, sourceLocation, comments, ignoredChars, additionalData);
+            return new DirectiveLocation(assertNotNull(name), sourceLocation, comments, ignoredChars, additionalData);
         }
     }
 }
diff --git a/src/main/java/graphql/language/DirectivesContainer.java b/src/main/java/graphql/language/DirectivesContainer.java
index a300072486..d3bf79a498 100644
--- a/src/main/java/graphql/language/DirectivesContainer.java
+++ b/src/main/java/graphql/language/DirectivesContainer.java
@@ -2,6 +2,7 @@
 
 
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
 
 import java.util.List;
 import java.util.Map;
@@ -15,6 +16,7 @@
  * @see DirectiveDefinition#isRepeatable()
  */
 @PublicApi
+@NullMarked
 public interface DirectivesContainer<T extends DirectivesContainer> extends Node<T> {
 
     /**
diff --git a/src/main/java/graphql/language/Document.java b/src/main/java/graphql/language/Document.java
index 1f613686e4..7195450f44 100644
--- a/src/main/java/graphql/language/Document.java
+++ b/src/main/java/graphql/language/Document.java
@@ -8,6 +8,9 @@
 import graphql.collect.ImmutableKit;
 import graphql.util.TraversalControl;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -21,6 +24,7 @@
 import static graphql.language.NodeChildrenContainer.newNodeChildrenContainer;
 
 @PublicApi
+@NullMarked
 public class Document extends AbstractNode<Document> {
 
     private final ImmutableList<Definition> definitions;
@@ -28,7 +32,7 @@ public class Document extends AbstractNode<Document> {
     public static final String CHILD_DEFINITIONS = "definitions";
 
     @Internal
-    protected Document(List<Definition> definitions, SourceLocation sourceLocation, List<Comment> comments, IgnoredChars ignoredChars, Map<String, String> additionalData) {
+    protected Document(List<Definition> definitions, @Nullable SourceLocation sourceLocation, List<Comment> comments, IgnoredChars ignoredChars, Map<String, String> additionalData) {
         super(sourceLocation, comments, ignoredChars, additionalData);
         this.definitions = ImmutableList.copyOf(definitions);
     }
@@ -114,7 +118,7 @@ public Document withNewChildren(NodeChildrenContainer newChildren) {
     }
 
     @Override
-    public boolean isEqualTo(Node o) {
+    public boolean isEqualTo(@Nullable Node o) {
         if (this == o) {
             return true;
         }
@@ -127,7 +131,7 @@ public boolean isEqualTo(Node o) {
 
     @Override
     public Document deepCopy() {
-        return new Document(deepCopy(definitions), getSourceLocation(), getComments(), getIgnoredChars(), getAdditionalData());
+        return new Document(assertNotNull(deepCopy(definitions)), getSourceLocation(), getComments(), getIgnoredChars(), getAdditionalData());
     }
 
     @Override
@@ -152,6 +156,7 @@ public Document transform(Consumer<Builder> builderConsumer) {
         return builder.build();
     }
 
+    @NullUnmarked
     public static final class Builder implements NodeBuilder {
         private ImmutableList<Definition> definitions = emptyList();
         private SourceLocation sourceLocation;
diff --git a/src/main/java/graphql/language/EnumTypeDefinition.java b/src/main/java/graphql/language/EnumTypeDefinition.java
index 51bad7b12a..af7dc26f34 100644
--- a/src/main/java/graphql/language/EnumTypeDefinition.java
+++ b/src/main/java/graphql/language/EnumTypeDefinition.java
@@ -6,6 +6,9 @@
 import graphql.collect.ImmutableKit;
 import graphql.util.TraversalControl;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
@@ -20,6 +23,7 @@
 import static graphql.language.NodeChildrenContainer.newNodeChildrenContainer;
 
 @PublicApi
+@NullMarked
 public class EnumTypeDefinition extends AbstractDescribedNode<EnumTypeDefinition> implements TypeDefinition<EnumTypeDefinition>, DirectivesContainer<EnumTypeDefinition>, NamedNode<EnumTypeDefinition> {
     private final String name;
     private final ImmutableList<EnumValueDefinition> enumValueDefinitions;
@@ -32,8 +36,8 @@ public class EnumTypeDefinition extends AbstractDescribedNode<EnumTypeDefinition
     protected EnumTypeDefinition(String name,
                                  List<EnumValueDefinition> enumValueDefinitions,
                                  List<Directive> directives,
-                                 Description description,
-                                 SourceLocation sourceLocation,
+                                 @Nullable Description description,
+                                 @Nullable SourceLocation sourceLocation,
                                  List<Comment> comments,
                                  IgnoredChars ignoredChars, Map<String, String> additionalData) {
         super(sourceLocation, comments, ignoredChars, additionalData, description);
@@ -105,7 +109,7 @@ public EnumTypeDefinition withNewChildren(NodeChildrenContainer newChildren) {
     }
 
     @Override
-    public boolean isEqualTo(Node o) {
+    public boolean isEqualTo(@Nullable Node o) {
         if (this == o) {
             return true;
         }
@@ -121,8 +125,8 @@ public boolean isEqualTo(Node o) {
     @Override
     public EnumTypeDefinition deepCopy() {
         return new EnumTypeDefinition(name,
-                deepCopy(enumValueDefinitions),
-                deepCopy(directives.getDirectives()),
+                assertNotNull(deepCopy(enumValueDefinitions)),
+                assertNotNull(deepCopy(directives.getDirectives())),
                 description,
                 getSourceLocation(),
                 getComments(),
@@ -154,6 +158,7 @@ public EnumTypeDefinition transform(Consumer<Builder> builderConsumer) {
         return builder.build();
     }
 
+    @NullUnmarked
     public static final class Builder implements NodeDirectivesBuilder {
         private SourceLocation sourceLocation;
         private ImmutableList<Comment> comments = emptyList();
@@ -236,7 +241,7 @@ public Builder additionalData(String key, String value) {
 
 
         public EnumTypeDefinition build() {
-            return new EnumTypeDefinition(name, enumValueDefinitions, directives, description, sourceLocation, comments, ignoredChars, additionalData);
+            return new EnumTypeDefinition(assertNotNull(name), enumValueDefinitions, directives, description, sourceLocation, comments, ignoredChars, additionalData);
         }
     }
 }
diff --git a/src/main/java/graphql/language/EnumTypeExtensionDefinition.java b/src/main/java/graphql/language/EnumTypeExtensionDefinition.java
index 82bb3eb634..357e251a61 100644
--- a/src/main/java/graphql/language/EnumTypeExtensionDefinition.java
+++ b/src/main/java/graphql/language/EnumTypeExtensionDefinition.java
@@ -4,6 +4,9 @@
 import graphql.Internal;
 import graphql.PublicApi;
 import graphql.collect.ImmutableKit;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -14,14 +17,15 @@
 import static graphql.collect.ImmutableKit.emptyList;
 
 @PublicApi
+@NullMarked
 public class EnumTypeExtensionDefinition extends EnumTypeDefinition implements SDLExtensionDefinition {
 
     @Internal
     protected EnumTypeExtensionDefinition(String name,
                                           List<EnumValueDefinition> enumValueDefinitions,
                                           List<Directive> directives,
-                                          Description description,
-                                          SourceLocation sourceLocation,
+                                          @Nullable Description description,
+                                          @Nullable SourceLocation sourceLocation,
                                           List<Comment> comments,
                                           IgnoredChars ignoredChars,
                                           Map<String, String> additionalData) {
@@ -32,8 +36,8 @@ protected EnumTypeExtensionDefinition(String name,
     @Override
     public EnumTypeExtensionDefinition deepCopy() {
         return new EnumTypeExtensionDefinition(getName(),
-                deepCopy(getEnumValueDefinitions()),
-                deepCopy(getDirectives()),
+                assertNotNull(deepCopy(getEnumValueDefinitions())),
+                assertNotNull(deepCopy(getDirectives())),
                 getDescription(),
                 getSourceLocation(),
                 getComments(),
@@ -67,6 +71,7 @@ public EnumTypeExtensionDefinition transformExtension(Consumer<Builder> builderC
         return builder.build();
     }
 
+    @NullUnmarked
     public static final class Builder implements NodeDirectivesBuilder {
         private SourceLocation sourceLocation;
         private ImmutableList<Comment> comments = emptyList();
@@ -144,7 +149,7 @@ public Builder additionalData(String key, String value) {
 
 
         public EnumTypeExtensionDefinition build() {
-            return new EnumTypeExtensionDefinition(name,
+            return new EnumTypeExtensionDefinition(assertNotNull(name),
                     enumValueDefinitions,
                     directives,
                     description,
diff --git a/src/main/java/graphql/language/EnumValueDefinition.java b/src/main/java/graphql/language/EnumValueDefinition.java
index 5e28ae87f9..86f5a2f00b 100644
--- a/src/main/java/graphql/language/EnumValueDefinition.java
+++ b/src/main/java/graphql/language/EnumValueDefinition.java
@@ -7,6 +7,9 @@
 import graphql.collect.ImmutableKit;
 import graphql.util.TraversalControl;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -20,6 +23,7 @@
 import static graphql.language.NodeChildrenContainer.newNodeChildrenContainer;
 
 @PublicApi
+@NullMarked
 public class EnumValueDefinition extends AbstractDescribedNode<EnumValueDefinition> implements DirectivesContainer<EnumValueDefinition>, NamedNode<EnumValueDefinition> {
     private final String name;
     private final NodeUtil.DirectivesHolder directives;
@@ -29,8 +33,8 @@ public class EnumValueDefinition extends AbstractDescribedNode<EnumValueDefiniti
     @Internal
     protected EnumValueDefinition(String name,
                                   List<Directive> directives,
-                                  Description description,
-                                  SourceLocation sourceLocation,
+                                  @Nullable Description description,
+                                  @Nullable SourceLocation sourceLocation,
                                   List<Comment> comments,
                                   IgnoredChars ignoredChars, Map<String, String> additionalData) {
         super(sourceLocation, comments, ignoredChars, additionalData, description);
@@ -102,7 +106,7 @@ public EnumValueDefinition withNewChildren(NodeChildrenContainer newChildren) {
     }
 
     @Override
-    public boolean isEqualTo(Node o) {
+    public boolean isEqualTo(@Nullable Node o) {
         if (this == o) {
             return true;
         }
@@ -118,7 +122,7 @@ public boolean isEqualTo(Node o) {
 
     @Override
     public EnumValueDefinition deepCopy() {
-        return new EnumValueDefinition(name, deepCopy(directives.getDirectives()), description, getSourceLocation(), getComments(), getIgnoredChars(), getAdditionalData());
+        return new EnumValueDefinition(name, assertNotNull(deepCopy(directives.getDirectives())), description, getSourceLocation(), getComments(), getIgnoredChars(), getAdditionalData());
     }
 
     @Override
@@ -144,6 +148,7 @@ public EnumValueDefinition transform(Consumer<Builder> builderConsumer) {
         return builder.build();
     }
 
+    @NullUnmarked
     public static final class Builder implements NodeDirectivesBuilder {
         private SourceLocation sourceLocation;
         private ImmutableList<Comment> comments = emptyList();
@@ -214,7 +219,7 @@ public Builder additionalData(String key, String value) {
 
 
         public EnumValueDefinition build() {
-            return new EnumValueDefinition(name, directives, description, sourceLocation, comments, ignoredChars, additionalData);
+            return new EnumValueDefinition(assertNotNull(name), directives, description, sourceLocation, comments, ignoredChars, additionalData);
         }
     }
 }
diff --git a/src/main/java/graphql/language/Field.java b/src/main/java/graphql/language/Field.java
index 45f9103f3d..ebb86f1e48 100644
--- a/src/main/java/graphql/language/Field.java
+++ b/src/main/java/graphql/language/Field.java
@@ -9,6 +9,9 @@
 import graphql.util.Interning;
 import graphql.util.TraversalControl;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -27,13 +30,14 @@
  * This might change in the future.
  */
 @PublicApi
+@NullMarked
 public class Field extends AbstractNode<Field> implements Selection<Field>, SelectionSetContainer<Field>, DirectivesContainer<Field>, NamedNode<Field> {
 
     private final String name;
-    private final String alias;
+    private final @Nullable String alias;
     private final ImmutableList<Argument> arguments;
     private final NodeUtil.DirectivesHolder directives;
-    private final SelectionSet selectionSet;
+    private final @Nullable SelectionSet selectionSet;
 
     public static final String CHILD_ARGUMENTS = "arguments";
     public static final String CHILD_DIRECTIVES = "directives";
@@ -42,16 +46,16 @@ public class Field extends AbstractNode<Field> implements Selection<Field>, Sele
 
     @Internal
     protected Field(String name,
-                    String alias,
+                    @Nullable String alias,
                     List<Argument> arguments,
                     List<Directive> directives,
-                    SelectionSet selectionSet,
-                    SourceLocation sourceLocation,
+                    @Nullable SelectionSet selectionSet,
+                    @Nullable SourceLocation sourceLocation,
                     List<Comment> comments,
                     IgnoredChars ignoredChars,
                     Map<String, String> additionalData) {
         super(sourceLocation, comments, ignoredChars, additionalData);
-        this.name = name == null ? null : Interning.intern(name);
+        this.name = Interning.intern(name);
         this.alias = alias;
         this.arguments = ImmutableList.copyOf(arguments);
         this.directives = NodeUtil.DirectivesHolder.of(directives);
@@ -133,7 +137,7 @@ public String getName() {
         return name;
     }
 
-    public String getAlias() {
+    public @Nullable String getAlias() {
         return alias;
     }
 
@@ -166,13 +170,13 @@ public boolean hasDirective(String directiveName) {
     }
 
     @Override
-    public SelectionSet getSelectionSet() {
+    public @Nullable SelectionSet getSelectionSet() {
         return selectionSet;
     }
 
 
     @Override
-    public boolean isEqualTo(Node o) {
+    public boolean isEqualTo(@Nullable Node o) {
         if (this == o) {
             return true;
         }
@@ -189,8 +193,8 @@ public boolean isEqualTo(Node o) {
     public Field deepCopy() {
         return new Field(name,
                 alias,
-                deepCopy(arguments),
-                deepCopy(directives.getDirectives()),
+                assertNotNull(deepCopy(arguments)),
+                assertNotNull(deepCopy(directives.getDirectives())),
                 deepCopy(selectionSet),
                 getSourceLocation(),
                 getComments(),
@@ -233,6 +237,7 @@ public Field transform(Consumer<Builder> builderConsumer) {
         return builder.build();
     }
 
+    @NullUnmarked
     public static final class Builder implements NodeDirectivesBuilder {
         private SourceLocation sourceLocation;
         private ImmutableList<Comment> comments = emptyList();
@@ -318,7 +323,7 @@ public Builder additionalData(String key, String value) {
 
 
         public Field build() {
-            return new Field(name, alias, arguments, directives, selectionSet, sourceLocation, comments, ignoredChars, additionalData);
+            return new Field(assertNotNull(name), alias, arguments, directives, selectionSet, sourceLocation, comments, ignoredChars, additionalData);
         }
     }
 }
diff --git a/src/main/java/graphql/language/FieldDefinition.java b/src/main/java/graphql/language/FieldDefinition.java
index 5fc03257aa..dc114895fb 100644
--- a/src/main/java/graphql/language/FieldDefinition.java
+++ b/src/main/java/graphql/language/FieldDefinition.java
@@ -7,6 +7,9 @@
 import graphql.collect.ImmutableKit;
 import graphql.util.TraversalControl;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
@@ -21,6 +24,7 @@
 import static graphql.language.NodeChildrenContainer.newNodeChildrenContainer;
 
 @PublicApi
+@NullMarked
 public class FieldDefinition extends AbstractDescribedNode<FieldDefinition> implements DirectivesContainer<FieldDefinition>, NamedNode<FieldDefinition> {
     private final String name;
     private final Type type;
@@ -36,8 +40,8 @@ protected FieldDefinition(String name,
                               Type type,
                               List<InputValueDefinition> inputValueDefinitions,
                               List<Directive> directives,
-                              Description description,
-                              SourceLocation sourceLocation,
+                              @Nullable Description description,
+                              @Nullable SourceLocation sourceLocation,
                               List<Comment> comments,
                               IgnoredChars ignoredChars,
                               Map<String, String> additionalData) {
@@ -107,14 +111,14 @@ public NodeChildrenContainer getNamedChildren() {
     @Override
     public FieldDefinition withNewChildren(NodeChildrenContainer newChildren) {
         return transform(builder -> builder
-                .type(newChildren.getChildOrNull(CHILD_TYPE))
+                .type(assertNotNull(newChildren.getChildOrNull(CHILD_TYPE)))
                 .inputValueDefinitions(newChildren.getChildren(CHILD_INPUT_VALUE_DEFINITION))
                 .directives(newChildren.getChildren(CHILD_DIRECTIVES))
         );
     }
 
     @Override
-    public boolean isEqualTo(Node o) {
+    public boolean isEqualTo(@Nullable Node o) {
         if (this == o) {
             return true;
         }
@@ -130,9 +134,9 @@ public boolean isEqualTo(Node o) {
     @Override
     public FieldDefinition deepCopy() {
         return new FieldDefinition(name,
-                deepCopy(type),
-                deepCopy(inputValueDefinitions),
-                deepCopy(directives.getDirectives()),
+                assertNotNull(deepCopy(type)),
+                assertNotNull(deepCopy(inputValueDefinitions)),
+                assertNotNull(deepCopy(directives.getDirectives())),
                 description,
                 getSourceLocation(),
                 getComments(),
@@ -165,6 +169,7 @@ public FieldDefinition transform(Consumer<Builder> builderConsumer) {
         return builder.build();
     }
 
+    @NullUnmarked
     public static final class Builder implements NodeDirectivesBuilder {
         private SourceLocation sourceLocation;
         private String name;
@@ -256,7 +261,7 @@ public Builder additionalData(String key, String value) {
 
 
         public FieldDefinition build() {
-            return new FieldDefinition(name, type, inputValueDefinitions, directives, description, sourceLocation, comments, ignoredChars, additionalData);
+            return new FieldDefinition(assertNotNull(name), assertNotNull(type), inputValueDefinitions, directives, description, sourceLocation, comments, ignoredChars, additionalData);
         }
     }
 }
diff --git a/src/main/java/graphql/language/FragmentDefinition.java b/src/main/java/graphql/language/FragmentDefinition.java
index 3913959607..79fcf609ef 100644
--- a/src/main/java/graphql/language/FragmentDefinition.java
+++ b/src/main/java/graphql/language/FragmentDefinition.java
@@ -7,6 +7,9 @@
 import graphql.collect.ImmutableKit;
 import graphql.util.TraversalControl;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
@@ -23,6 +26,7 @@
  * Provided to the DataFetcher, therefore public API
  */
 @PublicApi
+@NullMarked
 public class FragmentDefinition extends AbstractNode<FragmentDefinition> implements Definition<FragmentDefinition>, SelectionSetContainer<FragmentDefinition>, DirectivesContainer<FragmentDefinition>, NamedNode<FragmentDefinition> {
 
     private final String name;
@@ -39,7 +43,7 @@ protected FragmentDefinition(String name,
                                  TypeName typeCondition,
                                  List<Directive> directives,
                                  SelectionSet selectionSet,
-                                 SourceLocation sourceLocation,
+                                 @Nullable SourceLocation sourceLocation,
                                  List<Comment> comments,
                                  IgnoredChars ignoredChars,
                                  Map<String, String> additionalData) {
@@ -106,14 +110,14 @@ public NodeChildrenContainer getNamedChildren() {
     @Override
     public FragmentDefinition withNewChildren(NodeChildrenContainer newChildren) {
         return transform(builder -> builder
-                .typeCondition(newChildren.getChildOrNull(CHILD_TYPE_CONDITION))
+                .typeCondition(assertNotNull(newChildren.getChildOrNull(CHILD_TYPE_CONDITION)))
                 .directives(newChildren.getChildren(CHILD_DIRECTIVES))
-                .selectionSet(newChildren.getChildOrNull(CHILD_SELECTION_SET))
+                .selectionSet(assertNotNull(newChildren.getChildOrNull(CHILD_SELECTION_SET)))
         );
     }
 
     @Override
-    public boolean isEqualTo(Node o) {
+    public boolean isEqualTo(@Nullable Node o) {
         if (this == o) {
             return true;
         }
@@ -129,9 +133,9 @@ public boolean isEqualTo(Node o) {
     @Override
     public FragmentDefinition deepCopy() {
         return new FragmentDefinition(name,
-                deepCopy(typeCondition),
-                deepCopy(directives.getDirectives()),
-                deepCopy(selectionSet),
+                assertNotNull(deepCopy(typeCondition)),
+                assertNotNull(deepCopy(directives.getDirectives())),
+                assertNotNull(deepCopy(selectionSet)),
                 getSourceLocation(),
                 getComments(),
                 getIgnoredChars(),
@@ -163,6 +167,7 @@ public FragmentDefinition transform(Consumer<Builder> builderConsumer) {
         return builder.build();
     }
 
+    @NullUnmarked
     public static final class Builder implements NodeDirectivesBuilder {
         private SourceLocation sourceLocation;
         private ImmutableList<Comment> comments = emptyList();
@@ -242,7 +247,7 @@ public Builder additionalData(String key, String value) {
 
 
         public FragmentDefinition build() {
-            return new FragmentDefinition(name, typeCondition, directives, selectionSet, sourceLocation, comments, ignoredChars, additionalData);
+            return new FragmentDefinition(assertNotNull(name), assertNotNull(typeCondition), directives, assertNotNull(selectionSet), sourceLocation, comments, ignoredChars, additionalData);
         }
     }
 }
diff --git a/src/main/java/graphql/language/FragmentSpread.java b/src/main/java/graphql/language/FragmentSpread.java
index 36575b36ed..6775fddb8d 100644
--- a/src/main/java/graphql/language/FragmentSpread.java
+++ b/src/main/java/graphql/language/FragmentSpread.java
@@ -7,6 +7,9 @@
 import graphql.collect.ImmutableKit;
 import graphql.util.TraversalControl;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -20,6 +23,7 @@
 import static graphql.language.NodeChildrenContainer.newNodeChildrenContainer;
 
 @PublicApi
+@NullMarked
 public class FragmentSpread extends AbstractNode<FragmentSpread> implements Selection<FragmentSpread>, DirectivesContainer<FragmentSpread>, NamedNode<FragmentSpread> {
 
     private final String name;
@@ -28,7 +32,7 @@ public class FragmentSpread extends AbstractNode<FragmentSpread> implements Sele
     public static final String CHILD_DIRECTIVES = "directives";
 
     @Internal
-    protected FragmentSpread(String name, List<Directive> directives, SourceLocation sourceLocation, List<Comment> comments, IgnoredChars ignoredChars, Map<String, String> additionalData) {
+    protected FragmentSpread(String name, List<Directive> directives, @Nullable SourceLocation sourceLocation, List<Comment> comments, IgnoredChars ignoredChars, Map<String, String> additionalData) {
         super(sourceLocation, comments, ignoredChars, additionalData);
         this.name = name;
         this.directives = NodeUtil.DirectivesHolder.of(directives);
@@ -69,7 +73,7 @@ public boolean hasDirective(String directiveName) {
     }
 
     @Override
-    public boolean isEqualTo(Node o) {
+    public boolean isEqualTo(@Nullable Node o) {
         if (this == o) {
             return true;
         }
@@ -104,7 +108,7 @@ public FragmentSpread withNewChildren(NodeChildrenContainer newChildren) {
 
     @Override
     public FragmentSpread deepCopy() {
-        return new FragmentSpread(name, deepCopy(directives.getDirectives()), getSourceLocation(), getComments(), getIgnoredChars(), getAdditionalData());
+        return new FragmentSpread(name, assertNotNull(deepCopy(directives.getDirectives())), getSourceLocation(), getComments(), getIgnoredChars(), getAdditionalData());
     }
 
     @Override
@@ -135,6 +139,7 @@ public FragmentSpread transform(Consumer<Builder> builderConsumer) {
         return builder.build();
     }
 
+    @NullUnmarked
     public static final class Builder implements NodeDirectivesBuilder {
         private SourceLocation sourceLocation;
         private ImmutableList<Comment> comments = emptyList();
@@ -198,7 +203,7 @@ public Builder additionalData(String key, String value) {
         }
 
         public FragmentSpread build() {
-            return new FragmentSpread(name, directives, sourceLocation, comments, ignoredChars, additionalData);
+            return new FragmentSpread(assertNotNull(name), directives, sourceLocation, comments, ignoredChars, additionalData);
         }
     }
 }
diff --git a/src/main/java/graphql/language/IgnoredChar.java b/src/main/java/graphql/language/IgnoredChar.java
index eaa1689d0c..d316a4d6b1 100644
--- a/src/main/java/graphql/language/IgnoredChar.java
+++ b/src/main/java/graphql/language/IgnoredChar.java
@@ -1,6 +1,8 @@
 package graphql.language;
 
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.io.Serializable;
 import java.util.Objects;
@@ -12,6 +14,7 @@
  * This costs more memory but for certain use cases (like editors) this maybe be useful
  */
 @PublicApi
+@NullMarked
 public class IgnoredChar implements Serializable {
 
     public enum IgnoredCharKind {
@@ -51,7 +54,7 @@ public String toString() {
     }
 
     @Override
-    public boolean equals(Object o) {
+    public boolean equals(@Nullable Object o) {
         if (this == o) {
             return true;
         }
diff --git a/src/main/java/graphql/language/IgnoredChars.java b/src/main/java/graphql/language/IgnoredChars.java
index ce3a1ad59c..241b4cc744 100644
--- a/src/main/java/graphql/language/IgnoredChars.java
+++ b/src/main/java/graphql/language/IgnoredChars.java
@@ -3,6 +3,7 @@
 import com.google.common.collect.ImmutableList;
 import graphql.PublicApi;
 import graphql.collect.ImmutableKit;
+import org.jspecify.annotations.NullMarked;
 
 import java.io.Serializable;
 import java.util.List;
@@ -14,6 +15,7 @@
  * This costs more memory but for certain use cases (like editors) this maybe be useful
  */
 @PublicApi
+@NullMarked
 public class IgnoredChars implements Serializable {
 
     private final ImmutableList<IgnoredChar> left;
diff --git a/src/main/java/graphql/language/ImplementingTypeDefinition.java b/src/main/java/graphql/language/ImplementingTypeDefinition.java
index 31effe0d11..405ee1ccfa 100644
--- a/src/main/java/graphql/language/ImplementingTypeDefinition.java
+++ b/src/main/java/graphql/language/ImplementingTypeDefinition.java
@@ -2,6 +2,7 @@
 
 
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
 
 import java.util.List;
 
@@ -11,6 +12,7 @@
  * @param <T> for two
  */
 @PublicApi
+@NullMarked
 public interface ImplementingTypeDefinition<T extends TypeDefinition> extends TypeDefinition<T> {
 
     List<Type> getImplements();
diff --git a/src/main/java/graphql/language/InlineFragment.java b/src/main/java/graphql/language/InlineFragment.java
index b065a5b8df..173427071e 100644
--- a/src/main/java/graphql/language/InlineFragment.java
+++ b/src/main/java/graphql/language/InlineFragment.java
@@ -7,6 +7,9 @@
 import graphql.collect.ImmutableKit;
 import graphql.util.TraversalControl;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
@@ -20,8 +23,9 @@
 import static graphql.language.NodeChildrenContainer.newNodeChildrenContainer;
 
 @PublicApi
+@NullMarked
 public class InlineFragment extends AbstractNode<InlineFragment> implements Selection<InlineFragment>, SelectionSetContainer<InlineFragment>, DirectivesContainer<InlineFragment> {
-    private final TypeName typeCondition;
+    private final @Nullable TypeName typeCondition;
     private final NodeUtil.DirectivesHolder directives;
     private final SelectionSet selectionSet;
 
@@ -30,10 +34,10 @@ public class InlineFragment extends AbstractNode<InlineFragment> implements Sele
     public static final String CHILD_SELECTION_SET = "selectionSet";
 
     @Internal
-    protected InlineFragment(TypeName typeCondition,
+    protected InlineFragment(@Nullable TypeName typeCondition,
                              List<Directive> directives,
                              SelectionSet selectionSet,
-                             SourceLocation sourceLocation,
+                             @Nullable SourceLocation sourceLocation,
                              List<Comment> comments,
                              IgnoredChars ignoredChars,
                              Map<String, String> additionalData) {
@@ -48,8 +52,8 @@ protected InlineFragment(TypeName typeCondition,
      *
      * @param typeCondition the type condition of the inline fragment
      */
-    public InlineFragment(TypeName typeCondition) {
-        this(typeCondition, emptyList(), null, null, emptyList(), IgnoredChars.EMPTY, emptyMap());
+    public InlineFragment(@Nullable TypeName typeCondition) {
+        this(typeCondition, emptyList(), SelectionSet.newSelectionSet().build(), null, emptyList(), IgnoredChars.EMPTY, emptyMap());
     }
 
     /**
@@ -58,11 +62,11 @@ public InlineFragment(TypeName typeCondition) {
      * @param typeCondition the type condition of the inline fragment
      * @param selectionSet  of the inline fragment
      */
-    public InlineFragment(TypeName typeCondition, SelectionSet selectionSet) {
+    public InlineFragment(@Nullable TypeName typeCondition, SelectionSet selectionSet) {
         this(typeCondition, emptyList(), selectionSet, null, emptyList(), IgnoredChars.EMPTY, emptyMap());
     }
 
-    public TypeName getTypeCondition() {
+    public @Nullable TypeName getTypeCondition() {
         return typeCondition;
     }
 
@@ -121,7 +125,7 @@ public InlineFragment withNewChildren(NodeChildrenContainer newChildren) {
     }
 
     @Override
-    public boolean isEqualTo(Node o) {
+    public boolean isEqualTo(@Nullable Node o) {
         if (this == o) {
             return true;
         }
@@ -132,8 +136,8 @@ public boolean isEqualTo(Node o) {
     public InlineFragment deepCopy() {
         return new InlineFragment(
                 deepCopy(typeCondition),
-                deepCopy(directives.getDirectives()),
-                deepCopy(selectionSet),
+                assertNotNull(deepCopy(directives.getDirectives()), "directives cannot be null"),
+                assertNotNull(deepCopy(selectionSet), "selectionSet cannot be null"),
                 getSourceLocation(),
                 getComments(),
                 getIgnoredChars(),
@@ -164,6 +168,7 @@ public InlineFragment transform(Consumer<Builder> builderConsumer) {
         return builder.build();
     }
 
+    @NullUnmarked
     public static final class Builder implements NodeDirectivesBuilder {
         private SourceLocation sourceLocation;
         private ImmutableList<Comment> comments = emptyList();
diff --git a/src/main/java/graphql/language/InputObjectTypeDefinition.java b/src/main/java/graphql/language/InputObjectTypeDefinition.java
index d545814091..ce1a9c7425 100644
--- a/src/main/java/graphql/language/InputObjectTypeDefinition.java
+++ b/src/main/java/graphql/language/InputObjectTypeDefinition.java
@@ -7,6 +7,9 @@
 import graphql.util.FpKit;
 import graphql.util.TraversalControl;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -19,6 +22,7 @@
 import static graphql.language.NodeChildrenContainer.newNodeChildrenContainer;
 
 @PublicApi
+@NullMarked
 public class InputObjectTypeDefinition extends AbstractDescribedNode<InputObjectTypeDefinition> implements TypeDefinition<InputObjectTypeDefinition>, DirectivesContainer<InputObjectTypeDefinition>, NamedNode<InputObjectTypeDefinition> {
 
     private final String name;
@@ -32,8 +36,8 @@ public class InputObjectTypeDefinition extends AbstractDescribedNode<InputObject
     protected InputObjectTypeDefinition(String name,
                                         List<Directive> directives,
                                         List<InputValueDefinition> inputValueDefinitions,
-                                        Description description,
-                                        SourceLocation sourceLocation,
+                                        @Nullable Description description,
+                                        @Nullable SourceLocation sourceLocation,
                                         List<Comment> comments,
                                         IgnoredChars ignoredChars,
                                         Map<String, String> additionalData) {
@@ -94,7 +98,7 @@ public InputObjectTypeDefinition withNewChildren(NodeChildrenContainer newChildr
     }
 
     @Override
-    public boolean isEqualTo(Node o) {
+    public boolean isEqualTo(@Nullable Node o) {
         if (this == o) {
             return true;
         }
@@ -110,8 +114,8 @@ public boolean isEqualTo(Node o) {
     @Override
     public InputObjectTypeDefinition deepCopy() {
         return new InputObjectTypeDefinition(name,
-                deepCopy(directives.getDirectives()),
-                deepCopy(inputValueDefinitions),
+                assertNotNull(deepCopy(directives.getDirectives()), "directives cannot be null"),
+                assertNotNull(deepCopy(inputValueDefinitions), "inputValueDefinitions cannot be null"),
                 description,
                 getSourceLocation(),
                 getComments(),
@@ -144,6 +148,7 @@ public InputObjectTypeDefinition transform(Consumer<Builder> builderConsumer) {
         return builder.build();
     }
 
+    @NullUnmarked
     public static final class Builder implements NodeDirectivesBuilder {
         private SourceLocation sourceLocation;
         private ImmutableList<Comment> comments = emptyList();
diff --git a/src/main/java/graphql/language/InputObjectTypeExtensionDefinition.java b/src/main/java/graphql/language/InputObjectTypeExtensionDefinition.java
index 0835c0eb44..76c1b4055c 100644
--- a/src/main/java/graphql/language/InputObjectTypeExtensionDefinition.java
+++ b/src/main/java/graphql/language/InputObjectTypeExtensionDefinition.java
@@ -4,6 +4,9 @@
 import graphql.Internal;
 import graphql.PublicApi;
 import graphql.collect.ImmutableKit;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -14,14 +17,15 @@
 import static graphql.collect.ImmutableKit.emptyList;
 
 @PublicApi
+@NullMarked
 public class InputObjectTypeExtensionDefinition extends InputObjectTypeDefinition implements SDLExtensionDefinition {
 
     @Internal
     protected InputObjectTypeExtensionDefinition(String name,
                                                  List<Directive> directives,
                                                  List<InputValueDefinition> inputValueDefinitions,
-                                                 Description description,
-                                                 SourceLocation sourceLocation,
+                                                 @Nullable Description description,
+                                                 @Nullable SourceLocation sourceLocation,
                                                  List<Comment> comments,
                                                  IgnoredChars ignoredChars,
                                                  Map<String, String> additionalData) {
@@ -31,8 +35,8 @@ protected InputObjectTypeExtensionDefinition(String name,
     @Override
     public InputObjectTypeExtensionDefinition deepCopy() {
         return new InputObjectTypeExtensionDefinition(getName(),
-                deepCopy(getDirectives()),
-                deepCopy(getInputValueDefinitions()),
+                assertNotNull(deepCopy(getDirectives()), "directives cannot be null"),
+                assertNotNull(deepCopy(getInputValueDefinitions()), "inputValueDefinitions cannot be null"),
                 getDescription(),
                 getSourceLocation(),
                 getComments(),
@@ -67,6 +71,7 @@ public InputObjectTypeExtensionDefinition transformExtension(Consumer<Builder> b
         return builder.build();
     }
 
+    @NullUnmarked
     public static final class Builder implements NodeDirectivesBuilder {
         private SourceLocation sourceLocation;
         private ImmutableList<Comment> comments = emptyList();
diff --git a/src/main/java/graphql/language/InputValueDefinition.java b/src/main/java/graphql/language/InputValueDefinition.java
index c0db3318fa..0c2ca489b6 100644
--- a/src/main/java/graphql/language/InputValueDefinition.java
+++ b/src/main/java/graphql/language/InputValueDefinition.java
@@ -7,6 +7,9 @@
 import graphql.collect.ImmutableKit;
 import graphql.util.TraversalControl;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
@@ -21,10 +24,11 @@
 import static graphql.language.NodeChildrenContainer.newNodeChildrenContainer;
 
 @PublicApi
+@NullMarked
 public class InputValueDefinition extends AbstractDescribedNode<InputValueDefinition> implements DirectivesContainer<InputValueDefinition>, NamedNode<InputValueDefinition> {
     private final String name;
     private final Type type;
-    private final Value defaultValue;
+    private final @Nullable Value defaultValue;
     private final NodeUtil.DirectivesHolder directives;
 
     public static final String CHILD_TYPE = "type";
@@ -34,10 +38,10 @@ public class InputValueDefinition extends AbstractDescribedNode<InputValueDefini
     @Internal
     protected InputValueDefinition(String name,
                                    Type type,
-                                   Value defaultValue,
+                                   @Nullable Value defaultValue,
                                    List<Directive> directives,
-                                   Description description,
-                                   SourceLocation sourceLocation,
+                                   @Nullable Description description,
+                                   @Nullable SourceLocation sourceLocation,
                                    List<Comment> comments,
                                    IgnoredChars ignoredChars,
                                    Map<String, String> additionalData) {
@@ -70,7 +74,7 @@ public InputValueDefinition(String name,
 
     public InputValueDefinition(String name,
                                 Type type,
-                                Value defaultValue) {
+                                @Nullable Value defaultValue) {
         this(name, type, defaultValue, emptyList(), null, null, emptyList(), IgnoredChars.EMPTY, emptyMap());
 
     }
@@ -84,7 +88,7 @@ public String getName() {
         return name;
     }
 
-    public Value getDefaultValue() {
+    public @Nullable Value getDefaultValue() {
         return defaultValue;
     }
 
@@ -139,7 +143,7 @@ public InputValueDefinition withNewChildren(NodeChildrenContainer newChildren) {
     }
 
     @Override
-    public boolean isEqualTo(Node o) {
+    public boolean isEqualTo(@Nullable Node o) {
         if (this == o) {
             return true;
         }
@@ -155,9 +159,9 @@ public boolean isEqualTo(Node o) {
     @Override
     public InputValueDefinition deepCopy() {
         return new InputValueDefinition(name,
-                deepCopy(type),
+                assertNotNull(deepCopy(type), "type cannot be null"),
                 deepCopy(defaultValue),
-                deepCopy(directives.getDirectives()),
+                assertNotNull(deepCopy(directives.getDirectives()), "directives cannot be null"),
                 description,
                 getSourceLocation(),
                 getComments(),
@@ -190,6 +194,7 @@ public InputValueDefinition transform(Consumer<Builder> builderConsumer) {
         return builder.build();
     }
 
+    @NullUnmarked
     public static final class Builder implements NodeDirectivesBuilder {
         private SourceLocation sourceLocation;
         private ImmutableList<Comment> comments = emptyList();
diff --git a/src/main/java/graphql/language/InterfaceTypeDefinition.java b/src/main/java/graphql/language/InterfaceTypeDefinition.java
index 3fd1343f89..64f956e1ce 100644
--- a/src/main/java/graphql/language/InterfaceTypeDefinition.java
+++ b/src/main/java/graphql/language/InterfaceTypeDefinition.java
@@ -7,6 +7,9 @@
 import graphql.collect.ImmutableKit;
 import graphql.util.TraversalControl;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
@@ -21,6 +24,7 @@
 import static graphql.language.NodeChildrenContainer.newNodeChildrenContainer;
 
 @PublicApi
+@NullMarked
 public class InterfaceTypeDefinition extends AbstractDescribedNode<InterfaceTypeDefinition> implements ImplementingTypeDefinition<InterfaceTypeDefinition>, DirectivesContainer<InterfaceTypeDefinition>, NamedNode<InterfaceTypeDefinition> {
 
     private final String name;
@@ -37,8 +41,8 @@ protected InterfaceTypeDefinition(String name,
                                       List<Type> implementz,
                                       List<FieldDefinition> definitions,
                                       List<Directive> directives,
-                                      Description description,
-                                      SourceLocation sourceLocation,
+                                      @Nullable Description description,
+                                      @Nullable SourceLocation sourceLocation,
                                       List<Comment> comments,
                                       IgnoredChars ignoredChars,
                                       Map<String, String> additionalData) {
@@ -121,7 +125,7 @@ public InterfaceTypeDefinition withNewChildren(NodeChildrenContainer newChildren
     }
 
     @Override
-    public boolean isEqualTo(Node o) {
+    public boolean isEqualTo(@Nullable Node o) {
         if (this == o) {
             return true;
         }
@@ -137,9 +141,9 @@ public boolean isEqualTo(Node o) {
     @Override
     public InterfaceTypeDefinition deepCopy() {
         return new InterfaceTypeDefinition(name,
-                deepCopy(implementz),
-                deepCopy(definitions),
-                deepCopy(directives.getDirectives()),
+                assertNotNull(deepCopy(implementz), "implementz cannot be null"),
+                assertNotNull(deepCopy(definitions), "definitions cannot be null"),
+                assertNotNull(deepCopy(directives.getDirectives()), "directives cannot be null"),
                 description,
                 getSourceLocation(),
                 getComments(),
@@ -173,6 +177,7 @@ public InterfaceTypeDefinition transform(Consumer<Builder> builderConsumer) {
         return builder.build();
     }
 
+    @NullUnmarked
     public static final class Builder implements NodeDirectivesBuilder {
         private SourceLocation sourceLocation;
         private ImmutableList<Comment> comments = emptyList();
diff --git a/src/main/java/graphql/language/InterfaceTypeExtensionDefinition.java b/src/main/java/graphql/language/InterfaceTypeExtensionDefinition.java
index 2de917065b..6c5eb2bf4e 100644
--- a/src/main/java/graphql/language/InterfaceTypeExtensionDefinition.java
+++ b/src/main/java/graphql/language/InterfaceTypeExtensionDefinition.java
@@ -4,6 +4,9 @@
 import graphql.Internal;
 import graphql.PublicApi;
 import graphql.collect.ImmutableKit;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -14,6 +17,7 @@
 import static graphql.collect.ImmutableKit.emptyList;
 
 @PublicApi
+@NullMarked
 public class InterfaceTypeExtensionDefinition extends InterfaceTypeDefinition implements SDLExtensionDefinition {
 
     @Internal
@@ -21,8 +25,8 @@ protected InterfaceTypeExtensionDefinition(String name,
                                                List<Type> implementz,
                                                List<FieldDefinition> definitions,
                                                List<Directive> directives,
-                                               Description description,
-                                               SourceLocation sourceLocation,
+                                               @Nullable Description description,
+                                               @Nullable SourceLocation sourceLocation,
                                                List<Comment> comments,
                                                IgnoredChars ignoredChars,
                                                Map<String, String> additionalData) {
@@ -33,8 +37,8 @@ protected InterfaceTypeExtensionDefinition(String name,
     public InterfaceTypeExtensionDefinition deepCopy() {
         return new InterfaceTypeExtensionDefinition(getName(),
                 getImplements(),
-                deepCopy(getFieldDefinitions()),
-                deepCopy(getDirectives()),
+                assertNotNull(deepCopy(getFieldDefinitions()), "fieldDefinitions cannot be null"),
+                assertNotNull(deepCopy(getDirectives()), "directives cannot be null"),
                 getDescription(),
                 getSourceLocation(),
                 getComments(),
@@ -70,6 +74,7 @@ public InterfaceTypeExtensionDefinition transformExtension(Consumer<Builder> bui
         return builder.build();
     }
 
+    @NullUnmarked
     public static final class Builder implements NodeDirectivesBuilder {
         private SourceLocation sourceLocation;
         private ImmutableList<Comment> comments = emptyList();
diff --git a/src/main/java/graphql/language/ListType.java b/src/main/java/graphql/language/ListType.java
index f193179bb6..670ffe7d53 100644
--- a/src/main/java/graphql/language/ListType.java
+++ b/src/main/java/graphql/language/ListType.java
@@ -6,6 +6,9 @@
 import graphql.PublicApi;
 import graphql.util.TraversalControl;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -18,6 +21,7 @@
 import static graphql.language.NodeChildrenContainer.newNodeChildrenContainer;
 
 @PublicApi
+@NullMarked
 public class ListType extends AbstractNode<ListType> implements Type<ListType> {
 
     private final Type type;
@@ -25,7 +29,7 @@ public class ListType extends AbstractNode<ListType> implements Type<ListType> {
     public static final String CHILD_TYPE = "type";
 
     @Internal
-    protected ListType(Type type, SourceLocation sourceLocation, List<Comment> comments, IgnoredChars ignoredChars, Map<String, String> additionalData) {
+    protected ListType(Type type, @Nullable SourceLocation sourceLocation, List<Comment> comments, IgnoredChars ignoredChars, Map<String, String> additionalData) {
         super(sourceLocation, comments, ignoredChars, additionalData);
         this.type = type;
     }
@@ -63,7 +67,7 @@ public ListType withNewChildren(NodeChildrenContainer newChildren) {
     }
 
     @Override
-    public boolean isEqualTo(Node o) {
+    public boolean isEqualTo(@Nullable Node o) {
         if (this == o) {
             return true;
         }
@@ -76,7 +80,7 @@ public boolean isEqualTo(Node o) {
 
     @Override
     public ListType deepCopy() {
-        return new ListType(deepCopy(type), getSourceLocation(), getComments(), getIgnoredChars(), getAdditionalData());
+        return new ListType(assertNotNull(deepCopy(type), "type cannot be null"), getSourceLocation(), getComments(), getIgnoredChars(), getAdditionalData());
     }
 
     @Override
@@ -105,6 +109,7 @@ public ListType transform(Consumer<Builder> builderConsumer) {
         return builder.build();
     }
 
+    @NullUnmarked
     public static final class Builder implements NodeBuilder {
         private Type type;
         private SourceLocation sourceLocation;
diff --git a/src/main/java/graphql/language/NamedNode.java b/src/main/java/graphql/language/NamedNode.java
index 4e852dad45..21bfb30a5a 100644
--- a/src/main/java/graphql/language/NamedNode.java
+++ b/src/main/java/graphql/language/NamedNode.java
@@ -3,6 +3,7 @@
 
 import graphql.PublicApi;
 import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 /**
  * Represents a language node that has a name
@@ -12,7 +13,7 @@
 public interface NamedNode<T extends NamedNode> extends Node<T> {
 
     /**
-     * @return the name of this node
+     * @return the name of this node, or null if this node is anonymous (e.g. an anonymous operation definition)
      */
-    String getName();
+    @Nullable String getName();
 }
diff --git a/src/main/java/graphql/language/Node.java b/src/main/java/graphql/language/Node.java
index 962934d76b..917594b876 100644
--- a/src/main/java/graphql/language/Node.java
+++ b/src/main/java/graphql/language/Node.java
@@ -4,6 +4,7 @@
 import graphql.PublicApi;
 import graphql.util.TraversalControl;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
 import org.jspecify.annotations.Nullable;
 
 import java.io.Serializable;
@@ -21,6 +22,7 @@
  * Every Node is immutable
  */
 @PublicApi
+@NullMarked
 public interface Node<T extends Node> extends Serializable {
 
     /**
diff --git a/src/main/java/graphql/language/NodeChildrenContainer.java b/src/main/java/graphql/language/NodeChildrenContainer.java
index d2e1b06fea..a986ebca76 100644
--- a/src/main/java/graphql/language/NodeChildrenContainer.java
+++ b/src/main/java/graphql/language/NodeChildrenContainer.java
@@ -1,6 +1,9 @@
 package graphql.language;
 
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
@@ -15,6 +18,7 @@
  * Container of children of a {@link Node}.
  */
 @PublicApi
+@NullMarked
 public class NodeChildrenContainer {
 
     private final Map<String, List<Node>> children = new LinkedHashMap<>();
@@ -27,7 +31,7 @@ public <T extends Node> List<T> getChildren(String key) {
         return (List<T>) children.getOrDefault(key, emptyList());
     }
 
-    public <T extends Node> T getChildOrNull(String key) {
+    public <T extends Node> @Nullable T getChildOrNull(String key) {
         List<? extends Node> result = children.getOrDefault(key, emptyList());
         if (result.size() > 1) {
             throw new IllegalStateException("children " + key + " is not a single value");
@@ -61,6 +65,7 @@ public boolean isEmpty() {
         return this.children.isEmpty();
     }
 
+    @NullUnmarked
     public static class Builder {
         private final Map<String, List<Node>> children = new LinkedHashMap<>();
 
diff --git a/src/main/java/graphql/language/NodeDirectivesBuilder.java b/src/main/java/graphql/language/NodeDirectivesBuilder.java
index 3694165fab..12b793f3a9 100644
--- a/src/main/java/graphql/language/NodeDirectivesBuilder.java
+++ b/src/main/java/graphql/language/NodeDirectivesBuilder.java
@@ -1,10 +1,12 @@
 package graphql.language;
 
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
 
 import java.util.List;
 
 @PublicApi
+@NullMarked
 public interface NodeDirectivesBuilder extends NodeBuilder {
 
     NodeDirectivesBuilder directives(List<Directive> directives);
diff --git a/src/main/java/graphql/language/NodeParentTree.java b/src/main/java/graphql/language/NodeParentTree.java
index 91907e6ef0..7edc6e2dd3 100644
--- a/src/main/java/graphql/language/NodeParentTree.java
+++ b/src/main/java/graphql/language/NodeParentTree.java
@@ -4,11 +4,14 @@
 import graphql.Internal;
 import graphql.PublicApi;
 import graphql.collect.ImmutableKit;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.ArrayDeque;
 import java.util.ArrayList;
 import java.util.Deque;
 import java.util.List;
+import java.util.Objects;
 import java.util.Optional;
 
 import static graphql.Assert.assertNotNull;
@@ -21,10 +24,11 @@
  * on an ObjectTypeDefinition.
  */
 @PublicApi
+@NullMarked
 public class NodeParentTree<T extends Node> {
 
     private final T node;
-    private final NodeParentTree<T> parent;
+    private final @Nullable NodeParentTree<T> parent;
     private final ImmutableList<String> path;
 
     @Internal
@@ -45,7 +49,7 @@ public NodeParentTree(Deque<T> nodeStack) {
     private ImmutableList<String> mkPath(Deque<T> copy) {
         return ImmutableKit.filterAndMap(copy,
                 node1 -> node1 instanceof NamedNode,
-                node1 -> ((NamedNode) node1).getName());
+                node1 -> Objects.toString(((NamedNode) node1).getName(), ""));
     }
 
 
diff --git a/src/main/java/graphql/language/NodeTraverser.java b/src/main/java/graphql/language/NodeTraverser.java
index 916c290f95..a0f6ba8063 100644
--- a/src/main/java/graphql/language/NodeTraverser.java
+++ b/src/main/java/graphql/language/NodeTraverser.java
@@ -7,6 +7,7 @@
 import graphql.util.Traverser;
 import graphql.util.TraverserContext;
 import graphql.util.TraverserVisitor;
+import org.jspecify.annotations.NullMarked;
 
 import java.util.Collection;
 import java.util.Collections;
@@ -18,6 +19,7 @@
  * Lets you traverse a {@link Node} tree.
  */
 @PublicApi
+@NullMarked
 public class NodeTraverser {
 
 
diff --git a/src/main/java/graphql/language/NodeVisitor.java b/src/main/java/graphql/language/NodeVisitor.java
index 2ed79570b3..ca40709f5d 100644
--- a/src/main/java/graphql/language/NodeVisitor.java
+++ b/src/main/java/graphql/language/NodeVisitor.java
@@ -3,11 +3,13 @@
 import graphql.PublicApi;
 import graphql.util.TraversalControl;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
 
 /**
  * Used by {@link NodeTraverser} to visit {@link Node}.
  */
 @PublicApi
+@NullMarked
 public interface NodeVisitor {
     TraversalControl visitArgument(Argument node, TraverserContext<Node> data);
 
diff --git a/src/main/java/graphql/language/NodeVisitorStub.java b/src/main/java/graphql/language/NodeVisitorStub.java
index f0fcd6b3fd..b5d00073c4 100644
--- a/src/main/java/graphql/language/NodeVisitorStub.java
+++ b/src/main/java/graphql/language/NodeVisitorStub.java
@@ -3,11 +3,13 @@
 import graphql.PublicApi;
 import graphql.util.TraversalControl;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
 
 /**
  * Convenient implementation of {@link NodeVisitor} for easy subclassing methods handling different types of Nodes in one method.
  */
 @PublicApi
+@NullMarked
 public class NodeVisitorStub implements NodeVisitor {
     @Override
     public TraversalControl visitArgument(Argument node, TraverserContext<Node> context) {
diff --git a/src/main/java/graphql/language/NonNullType.java b/src/main/java/graphql/language/NonNullType.java
index e86e39c244..da38a1b414 100644
--- a/src/main/java/graphql/language/NonNullType.java
+++ b/src/main/java/graphql/language/NonNullType.java
@@ -6,6 +6,9 @@
 import graphql.PublicApi;
 import graphql.util.TraversalControl;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -18,6 +21,7 @@
 import static graphql.language.NodeChildrenContainer.newNodeChildrenContainer;
 
 @PublicApi
+@NullMarked
 public class NonNullType extends AbstractNode<NonNullType> implements Type<NonNullType> {
 
     private final Type type;
@@ -25,7 +29,7 @@ public class NonNullType extends AbstractNode<NonNullType> implements Type<NonNu
     public static final String CHILD_TYPE = "type";
 
     @Internal
-    protected NonNullType(Type type, SourceLocation sourceLocation, List<Comment> comments, IgnoredChars ignoredChars, Map<String, String> additionalData) {
+    protected NonNullType(Type type, @Nullable SourceLocation sourceLocation, List<Comment> comments, IgnoredChars ignoredChars, Map<String, String> additionalData) {
         super(sourceLocation, comments, ignoredChars, additionalData);
         this.type = type;
     }
@@ -63,7 +67,7 @@ public NonNullType withNewChildren(NodeChildrenContainer newChildren) {
     }
 
     @Override
-    public boolean isEqualTo(Node o) {
+    public boolean isEqualTo(@Nullable Node o) {
         if (this == o) {
             return true;
         }
@@ -77,7 +81,7 @@ public boolean isEqualTo(Node o) {
 
     @Override
     public NonNullType deepCopy() {
-        return new NonNullType(deepCopy(type), getSourceLocation(), getComments(), getIgnoredChars(), getAdditionalData());
+        return new NonNullType(assertNotNull(deepCopy(type), "type deepCopy should not return null"), getSourceLocation(), getComments(), getIgnoredChars(), getAdditionalData());
     }
 
     @Override
@@ -106,6 +110,7 @@ public NonNullType transform(Consumer<Builder> builderConsumer) {
         return builder.build();
     }
 
+    @NullUnmarked
     public static final class Builder implements NodeBuilder {
         private SourceLocation sourceLocation;
         private Type type;
diff --git a/src/main/java/graphql/language/ObjectField.java b/src/main/java/graphql/language/ObjectField.java
index 8c4532a41c..23b1db02e1 100644
--- a/src/main/java/graphql/language/ObjectField.java
+++ b/src/main/java/graphql/language/ObjectField.java
@@ -7,6 +7,9 @@
 import graphql.collect.ImmutableKit;
 import graphql.util.TraversalControl;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -19,6 +22,7 @@
 import static graphql.language.NodeChildrenContainer.newNodeChildrenContainer;
 
 @PublicApi
+@NullMarked
 public class ObjectField extends AbstractNode<ObjectField> implements NamedNode<ObjectField> {
 
     private final String name;
@@ -27,7 +31,7 @@ public class ObjectField extends AbstractNode<ObjectField> implements NamedNode<
     public static final String CHILD_VALUE = "value";
 
     @Internal
-    protected ObjectField(String name, Value value, SourceLocation sourceLocation, List<Comment> comments, IgnoredChars ignoredChars, Map<String, String> additionalData) {
+    protected ObjectField(String name, Value value, @Nullable SourceLocation sourceLocation, List<Comment> comments, IgnoredChars ignoredChars, Map<String, String> additionalData) {
         super(sourceLocation, comments, ignoredChars, additionalData);
         this.name = assertNotNull(name);
         this.value = assertNotNull(value);
@@ -72,7 +76,7 @@ public ObjectField withNewChildren(NodeChildrenContainer newChildren) {
     }
 
     @Override
-    public boolean isEqualTo(Node o) {
+    public boolean isEqualTo(@Nullable Node o) {
         if (this == o) {
             return true;
         }
@@ -88,7 +92,7 @@ public boolean isEqualTo(Node o) {
 
     @Override
     public ObjectField deepCopy() {
-        return new ObjectField(name, deepCopy(this.value), getSourceLocation(), getComments(), getIgnoredChars(), getAdditionalData());
+        return new ObjectField(name, assertNotNull(deepCopy(this.value), "value deepCopy should not return null"), getSourceLocation(), getComments(), getIgnoredChars(), getAdditionalData());
     }
 
     @Override
@@ -114,6 +118,7 @@ public ObjectField transform(Consumer<Builder> builderConsumer) {
         return builder.build();
     }
 
+    @NullUnmarked
     public static final class Builder implements NodeBuilder {
         private SourceLocation sourceLocation;
         private String name;
diff --git a/src/main/java/graphql/language/ObjectTypeDefinition.java b/src/main/java/graphql/language/ObjectTypeDefinition.java
index fca017594e..1f8c37a39a 100644
--- a/src/main/java/graphql/language/ObjectTypeDefinition.java
+++ b/src/main/java/graphql/language/ObjectTypeDefinition.java
@@ -7,6 +7,9 @@
 import graphql.collect.ImmutableKit;
 import graphql.util.TraversalControl;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
@@ -21,6 +24,7 @@
 import static graphql.language.NodeChildrenContainer.newNodeChildrenContainer;
 
 @PublicApi
+@NullMarked
 public class ObjectTypeDefinition extends AbstractDescribedNode<ObjectTypeDefinition> implements ImplementingTypeDefinition<ObjectTypeDefinition>, DirectivesContainer<ObjectTypeDefinition>, NamedNode<ObjectTypeDefinition> {
     private final String name;
     private final ImmutableList<Type> implementz;
@@ -36,8 +40,8 @@ protected ObjectTypeDefinition(String name,
                                    List<Type> implementz,
                                    List<Directive> directives,
                                    List<FieldDefinition> fieldDefinitions,
-                                   Description description,
-                                   SourceLocation sourceLocation,
+                                   @Nullable Description description,
+                                   @Nullable SourceLocation sourceLocation,
                                    List<Comment> comments,
                                    IgnoredChars ignoredChars,
                                    Map<String, String> additionalData) {
@@ -117,7 +121,7 @@ public ObjectTypeDefinition withNewChildren(NodeChildrenContainer newChildren) {
     }
 
     @Override
-    public boolean isEqualTo(Node o) {
+    public boolean isEqualTo(@Nullable Node o) {
         if (this == o) {
             return true;
         }
@@ -133,9 +137,9 @@ public boolean isEqualTo(Node o) {
     @Override
     public ObjectTypeDefinition deepCopy() {
         return new ObjectTypeDefinition(name,
-                deepCopy(implementz),
-                deepCopy(directives.getDirectives()),
-                deepCopy(fieldDefinitions),
+                assertNotNull(deepCopy(implementz), "implementz deepCopy should not return null"),
+                assertNotNull(deepCopy(directives.getDirectives()), "directives deepCopy should not return null"),
+                assertNotNull(deepCopy(fieldDefinitions), "fieldDefinitions deepCopy should not return null"),
                 description,
                 getSourceLocation(),
                 getComments(),
@@ -168,6 +172,7 @@ public ObjectTypeDefinition transform(Consumer<Builder> builderConsumer) {
         return builder.build();
     }
 
+    @NullUnmarked
     public static final class Builder implements NodeDirectivesBuilder {
         private SourceLocation sourceLocation;
         private ImmutableList<Comment> comments = emptyList();
diff --git a/src/main/java/graphql/language/ObjectTypeExtensionDefinition.java b/src/main/java/graphql/language/ObjectTypeExtensionDefinition.java
index 575827564f..8e3477b8d4 100644
--- a/src/main/java/graphql/language/ObjectTypeExtensionDefinition.java
+++ b/src/main/java/graphql/language/ObjectTypeExtensionDefinition.java
@@ -5,6 +5,9 @@
 import graphql.Internal;
 import graphql.PublicApi;
 import graphql.collect.ImmutableKit;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.LinkedHashMap;
 import java.util.List;
@@ -16,6 +19,7 @@
 import static graphql.collect.ImmutableKit.emptyMap;
 
 @PublicApi
+@NullMarked
 public class ObjectTypeExtensionDefinition extends ObjectTypeDefinition implements SDLExtensionDefinition {
 
     @Internal
@@ -23,8 +27,8 @@ protected ObjectTypeExtensionDefinition(String name,
                                             List<Type> implementz,
                                             List<Directive> directives,
                                             List<FieldDefinition> fieldDefinitions,
-                                            Description description,
-                                            SourceLocation sourceLocation,
+                                            @Nullable Description description,
+                                            @Nullable SourceLocation sourceLocation,
                                             List<Comment> comments,
                                             IgnoredChars ignoredChars,
                                             Map<String, String> additionalData) {
@@ -44,9 +48,9 @@ public ObjectTypeExtensionDefinition(String name) {
     @Override
     public ObjectTypeExtensionDefinition deepCopy() {
         return new ObjectTypeExtensionDefinition(getName(),
-                deepCopy(getImplements()),
-                deepCopy(getDirectives()),
-                deepCopy(getFieldDefinitions()),
+                assertNotNull(deepCopy(getImplements()), "implementz deepCopy should not return null"),
+                assertNotNull(deepCopy(getDirectives()), "directives deepCopy should not return null"),
+                assertNotNull(deepCopy(getFieldDefinitions()), "fieldDefinitions deepCopy should not return null"),
                 getDescription(),
                 getSourceLocation(),
                 getComments(),
@@ -81,6 +85,7 @@ public ObjectTypeExtensionDefinition transformExtension(Consumer<Builder> builde
         return builder.build();
     }
 
+    @NullUnmarked
     public static final class Builder implements NodeDirectivesBuilder {
         private SourceLocation sourceLocation;
         private ImmutableList<Comment> comments = emptyList();
diff --git a/src/main/java/graphql/language/OperationDefinition.java b/src/main/java/graphql/language/OperationDefinition.java
index 824180bb49..845dd4e146 100644
--- a/src/main/java/graphql/language/OperationDefinition.java
+++ b/src/main/java/graphql/language/OperationDefinition.java
@@ -8,6 +8,9 @@
 import graphql.language.NodeUtil.DirectivesHolder;
 import graphql.util.TraversalControl;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
@@ -22,13 +25,14 @@
 import static graphql.language.NodeChildrenContainer.newNodeChildrenContainer;
 
 @PublicApi
+@NullMarked
 public class OperationDefinition extends AbstractNode<OperationDefinition> implements Definition<OperationDefinition>, SelectionSetContainer<OperationDefinition>, DirectivesContainer<OperationDefinition>, NamedNode<OperationDefinition> {
 
     public enum Operation {
         QUERY, MUTATION, SUBSCRIPTION
     }
 
-    private final String name;
+    private final @Nullable String name;
 
     private final Operation operation;
     private final ImmutableList<VariableDefinition> variableDefinitions;
@@ -40,12 +44,12 @@ public enum Operation {
     public static final String CHILD_SELECTION_SET = "selectionSet";
 
     @Internal
-    protected OperationDefinition(String name,
+    protected OperationDefinition(@Nullable String name,
                                   Operation operation,
                                   List<VariableDefinition> variableDefinitions,
                                   List<Directive> directives,
                                   SelectionSet selectionSet,
-                                  SourceLocation sourceLocation,
+                                  @Nullable SourceLocation sourceLocation,
                                   List<Comment> comments,
                                   IgnoredChars ignoredChars,
                                   Map<String, String> additionalData) {
@@ -57,15 +61,6 @@ protected OperationDefinition(String name,
         this.selectionSet = selectionSet;
     }
 
-    public OperationDefinition(String name,
-                               Operation operation) {
-        this(name, operation, emptyList(), emptyList(), null, null, emptyList(), IgnoredChars.EMPTY, emptyMap());
-    }
-
-    public OperationDefinition(String name) {
-        this(name, null, emptyList(), emptyList(), null, null, emptyList(), IgnoredChars.EMPTY, emptyMap());
-    }
-
     @Override
     public List<Node> getChildren() {
         List<Node> result = new ArrayList<>();
@@ -93,7 +88,8 @@ public OperationDefinition withNewChildren(NodeChildrenContainer newChildren) {
         );
     }
 
-    public String getName() {
+    @Override
+    public @Nullable String getName() {
         return name;
     }
 
@@ -130,7 +126,7 @@ public SelectionSet getSelectionSet() {
     }
 
     @Override
-    public boolean isEqualTo(Node o) {
+    public boolean isEqualTo(@Nullable Node o) {
         if (this == o) {
             return true;
         }
@@ -148,9 +144,9 @@ public boolean isEqualTo(Node o) {
     public OperationDefinition deepCopy() {
         return new OperationDefinition(name,
                 operation,
-                deepCopy(variableDefinitions),
-                deepCopy(directives.getDirectives()),
-                deepCopy(selectionSet),
+                assertNotNull(deepCopy(variableDefinitions), "variableDefinitions deepCopy should not return null"),
+                assertNotNull(deepCopy(directives.getDirectives()), "directives deepCopy should not return null"),
+                assertNotNull(deepCopy(selectionSet), "selectionSet deepCopy should not return null"),
                 getSourceLocation(),
                 getComments(),
                 getIgnoredChars(),
@@ -183,11 +179,12 @@ public OperationDefinition transform(Consumer<Builder> builderConsumer) {
         return builder.build();
     }
 
+    @NullUnmarked
     public static final class Builder implements NodeDirectivesBuilder {
         private SourceLocation sourceLocation;
         private ImmutableList<Comment> comments = emptyList();
         private String name;
-        private Operation operation;
+        private Operation operation = Operation.QUERY;
         private ImmutableList<VariableDefinition> variableDefinitions = emptyList();
         private ImmutableList<Directive> directives = emptyList();
         private SelectionSet selectionSet;
diff --git a/src/main/java/graphql/language/OperationTypeDefinition.java b/src/main/java/graphql/language/OperationTypeDefinition.java
index 5041e692cf..c1186aa751 100644
--- a/src/main/java/graphql/language/OperationTypeDefinition.java
+++ b/src/main/java/graphql/language/OperationTypeDefinition.java
@@ -6,6 +6,9 @@
 import graphql.PublicApi;
 import graphql.util.TraversalControl;
 import graphql.util.TraverserContext;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
@@ -20,6 +23,7 @@
 import static graphql.language.NodeChildrenContainer.newNodeChildrenContainer;
 
 @PublicApi
+@NullMarked
 public class OperationTypeDefinition extends AbstractNode<OperationTypeDefinition> implements NamedNode<OperationTypeDefinition> {
 
     private final String name;
@@ -28,7 +32,7 @@ public class OperationTypeDefinition extends AbstractNode<OperationTypeDefinitio
     public static final String CHILD_TYPE_NAME = "typeName";
 
     @Internal
-    protected OperationTypeDefinition(String name, TypeName typeName, SourceLocation sourceLocation, List<Comment> comments, IgnoredChars ignoredChars, Map<String, String> additionalData) {
+    protected OperationTypeDefinition(String name, TypeName typeName, @Nullable SourceLocation sourceLocation, List<Comment> comments, IgnoredChars ignoredChars, Map<String, String> additionalData) {
         super(sourceLocation, comments, ignoredChars, additionalData);
         this.name = name;
         this.typeName = typeName;
@@ -75,7 +79,7 @@ public OperationTypeDefinition withNewChildren(NodeChildrenContainer newChildren
     }
 
     @Override
-    public boolean isEqualTo(Node o) {
+    public boolean isEqualTo(@Nullable Node o) {
         if (this == o) {
             return true;
         }
@@ -90,7 +94,7 @@ public boolean isEqualTo(Node o) {
 
     @Override
     public OperationTypeDefinition deepCopy() {
-        return new OperationTypeDefinition(name, deepCopy(typeName), getSourceLocation(), getComments(), getIgnoredChars(), getAdditionalData());
+        return new OperationTypeDefinition(name, assertNotNull(deepCopy(typeName), "typeName deepCopy should not return null"), getSourceLocation(), getComments(), getIgnoredChars(), getAdditionalData());
     }
 
     @Override
@@ -116,6 +120,7 @@ public OperationTypeDefinition transform(Consumer<Builder> builderConsumer) {
         return builder.build();
     }
 
+    @NullUnmarked
     public static final class Builder implements NodeBuilder {
         private SourceLocation sourceLocation;
         private ImmutableList<Comment> comments = emptyList();
diff --git a/src/main/java/graphql/language/PrettyAstPrinter.java b/src/main/java/graphql/language/PrettyAstPrinter.java
index a5fc4628b1..5b2bac45ec 100644
--- a/src/main/java/graphql/language/PrettyAstPrinter.java
+++ b/src/main/java/graphql/language/PrettyAstPrinter.java
@@ -5,6 +5,9 @@
 import graphql.parser.CommentParser;
 import graphql.parser.NodeToRuleCapturingParser;
 import graphql.parser.ParserEnvironment;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.NullUnmarked;
+import org.jspecify.annotations.Nullable;
 
 import java.util.Collections;
 import java.util.List;
@@ -26,6 +29,7 @@
  * @see AstPrinter
  */
 @ExperimentalApi
+@NullMarked
 public class PrettyAstPrinter extends AstPrinter {
     private final CommentParser commentParser;
     private final PrettyPrinterOptions options;
@@ -218,7 +222,7 @@ private NodePrinter<UnionTypeDefinition> unionTypeDefinition(String nodeName) {
         };
     }
 
-    private String node(Node node, Class startClass) {
+    private String node(Node node, @Nullable Class startClass) {
         if (startClass != null) {
             assertTrue(startClass.isInstance(node), "The starting class must be in the inherit tree");
         }
@@ -238,15 +242,15 @@ private String node(Node node, Class startClass) {
         return builder.toString();
     }
 
-    private <T> boolean isEmpty(List<T> list) {
+    private <T> boolean isEmpty(@Nullable List<T> list) {
         return list == null || list.isEmpty();
     }
 
-    private boolean isEmpty(String s) {
+    private boolean isEmpty(@Nullable String s) {
         return s == null || s.isBlank();
     }
 
-    private <T> List<T> nvl(List<T> list) {
+    private <T> List<T> nvl(@Nullable List<T> list) {
         return list != null ? list : ImmutableKit.emptyList();
     }
 
@@ -318,7 +322,7 @@ private String node(Node node) {
         return node(node, null);
     }
 
-    private String spaced(String... args) {
+    private String spaced(@Nullable String... args) {
         return join(" ", args);
     }
 
@@ -330,7 +334,7 @@ private Function<String, String> append(String suffix) {
         return text -> text + suffix;
     }
 
-    private String join(String delim, String... args) {
+    private String join(String delim, @Nullable String... args) {
         StringJoiner joiner = new StringJoiner(delim);
 
         for (final String arg : args) {
@@ -342,7 +346,7 @@ private String join(String delim, String... args) {
         return joiner.toString();
     }
 
-    private <T extends Node> String block(List<T> nodes, Node parentNode, String prefix, String suffix, String separatorMultiline, String separatorSingleLine, String whenEmpty) {
+    private <T extends Node> String block(List<T> nodes, Node parentNode, String prefix, String suffix, String separatorMultiline, @Nullable String separatorSingleLine, @Nullable String whenEmpty) {
         if (isEmpty(nodes)) {
             return whenEmpty != null ? whenEmpty : prefix + suffix;
         }
@@ -429,6 +433,7 @@ public enum IndentType {
             }
         }
 
+        @NullUnmarked
         public static class Builder {
             private IndentType indentType;
             private int indentWidth = 1;
diff --git a/src/main/java/graphql/language/SDLDefinition.java b/src/main/java/graphql/language/SDLDefinition.java
index 7b07a24919..0e7cfe3420 100644
--- a/src/main/java/graphql/language/SDLDefinition.java
+++ b/src/main/java/graphql/language/SDLDefinition.java
@@ -2,6 +2,7 @@
 
 
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
 
 /**
  * An interface for Schema Definition Language (SDL) definitions.
@@ -9,6 +10,7 @@
  * @param <T> the actual Node type
  */
 @PublicApi
+@NullMarked
 public interface SDLDefinition<T extends SDLDefinition> extends Definition<T> {
 
 }
diff --git a/src/main/java/graphql/language/SDLExtensionDefinition.java b/src/main/java/graphql/language/SDLExtensionDefinition.java
index 2b71cd46ab..a955b8aad5 100644
--- a/src/main/java/graphql/language/SDLExtensionDefinition.java
+++ b/src/main/java/graphql/language/SDLExtensionDefinition.java
@@ -2,11 +2,13 @@
 
 
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
 
 /**
  * A marker interface for Schema Definition Language (SDL) extension definitions.
  */
 @PublicApi
+@NullMarked
 public interface SDLExtensionDefinition {
 
 }
diff --git a/src/main/java/graphql/language/SDLNamedDefinition.java b/src/main/java/graphql/language/SDLNamedDefinition.java
index 44b4bf85a6..c773761424 100644
--- a/src/main/java/graphql/language/SDLNamedDefinition.java
+++ b/src/main/java/graphql/language/SDLNamedDefinition.java
@@ -2,6 +2,7 @@
 
 
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
 
 /**
  * A interface for named Schema Definition Language (SDL) definition.
@@ -9,6 +10,7 @@
  * @param <T> the actual Node type
  */
 @PublicApi
+@NullMarked
 public interface SDLNamedDefinition<T extends SDLNamedDefinition> extends SDLDefinition<T> {
 
     /**
diff --git a/src/main/java/graphql/language/SourceLocation.java b/src/main/java/graphql/language/SourceLocation.java
index a4ae90a039..b97cc103ac 100644
--- a/src/main/java/graphql/language/SourceLocation.java
+++ b/src/main/java/graphql/language/SourceLocation.java
@@ -7,24 +7,27 @@
 import graphql.schema.GraphQLSchemaElement;
 import graphql.schema.GraphQLTypeUtil;
 import graphql.schema.idl.SchemaGenerator;
+import org.jspecify.annotations.NullMarked;
+import org.jspecify.annotations.Nullable;
 
 import java.io.Serializable;
 import java.util.Objects;
 
 @PublicApi
+@NullMarked
 public class SourceLocation implements Serializable {
 
     public static final SourceLocation EMPTY = new SourceLocation(-1, -1);
 
     private final int line;
     private final int column;
-    private final String sourceName;
+    private final @Nullable String sourceName;
 
     public SourceLocation(int line, int column) {
         this(line, column, null);
     }
 
-    public SourceLocation(int line, int column, String sourceName) {
+    public SourceLocation(int line, int column, @Nullable String sourceName) {
         this.line = line;
         this.column = column;
         this.sourceName = sourceName;
@@ -38,12 +41,12 @@ public int getColumn() {
         return column;
     }
 
-    public String getSourceName() {
+    public @Nullable String getSourceName() {
         return sourceName;
     }
 
     @Override
-    public boolean equals(Object o) {
+    public boolean equals(@Nullable Object o) {
         if (this == o) {
             return true;
         }
@@ -91,7 +94,7 @@ public String toString() {
      *
      * @return the source location if available or null if it's not.
      */
-    public static SourceLocation getLocation(GraphQLSchemaElement schemaElement) {
+    public static @Nullable SourceLocation getLocation(GraphQLSchemaElement schemaElement) {
         if (schemaElement instanceof GraphQLModifiedType) {
             schemaElement = GraphQLTypeUtil.unwrapAllAs((GraphQLModifiedType) schemaElement);
         }
diff --git a/src/main/java/graphql/language/Type.java b/src/main/java/graphql/language/Type.java
index a3141e56d0..85d06564de 100644
--- a/src/main/java/graphql/language/Type.java
+++ b/src/main/java/graphql/language/Type.java
@@ -2,8 +2,10 @@
 
 
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
 
 @PublicApi
+@NullMarked
 public interface Type<T extends Type> extends Node<T> {
 
 }
diff --git a/src/main/java/graphql/language/TypeDefinition.java b/src/main/java/graphql/language/TypeDefinition.java
index f75c2c5147..d70fc3ed60 100644
--- a/src/main/java/graphql/language/TypeDefinition.java
+++ b/src/main/java/graphql/language/TypeDefinition.java
@@ -2,6 +2,7 @@
 
 
 import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
 
 /**
  * An interface for type definitions in a Schema Definition Language (SDL).
@@ -9,6 +10,9 @@
  * @param <T> the actual Node type
  */
 @PublicApi
+@NullMarked
 public interface TypeDefinition<T extends TypeDefinition> extends SDLNamedDefinition<T>, DirectivesContainer<T>, NamedNode<T> {
 
+    @Override
+    String getName();
 }
diff --git a/src/main/java/graphql/normalized/ExecutableNormalizedOperation.java b/src/main/java/graphql/normalized/ExecutableNormalizedOperation.java
index cfcda2746d..2200d02777 100644
--- a/src/main/java/graphql/normalized/ExecutableNormalizedOperation.java
+++ b/src/main/java/graphql/normalized/ExecutableNormalizedOperation.java
@@ -1,10 +1,12 @@
 package graphql.normalized;
 
+import com.google.common.collect.ImmutableList;
 import com.google.common.collect.ImmutableListMultimap;
 import graphql.Assert;
 import graphql.PublicApi;
 import graphql.execution.MergedField;
 import graphql.execution.ResultPath;
+import graphql.execution.directives.QueryAppliedDirective;
 import graphql.execution.directives.QueryDirectives;
 import graphql.language.Field;
 import graphql.language.OperationDefinition;
@@ -25,6 +27,7 @@
 @PublicApi
 public class ExecutableNormalizedOperation {
     private final OperationDefinition.Operation operation;
+    private final Map<String, ImmutableList<QueryAppliedDirective>> operationDirectives;
     private final String operationName;
     private final List<ExecutableNormalizedField> topLevelFields;
     private final ImmutableListMultimap<Field, ExecutableNormalizedField> fieldToNormalizedField;
@@ -37,6 +40,7 @@ public class ExecutableNormalizedOperation {
     public ExecutableNormalizedOperation(
             OperationDefinition.Operation operation,
             String operationName,
+            Map<String, ImmutableList<QueryAppliedDirective>> operationDirectives,
             List<ExecutableNormalizedField> topLevelFields,
             ImmutableListMultimap<Field, ExecutableNormalizedField> fieldToNormalizedField,
             Map<ExecutableNormalizedField, MergedField> normalizedFieldToMergedField,
@@ -46,6 +50,7 @@ public ExecutableNormalizedOperation(
             int operationDepth) {
         this.operation = operation;
         this.operationName = operationName;
+        this.operationDirectives = operationDirectives;
         this.topLevelFields = topLevelFields;
         this.fieldToNormalizedField = fieldToNormalizedField;
         this.normalizedFieldToMergedField = normalizedFieldToMergedField;
@@ -69,6 +74,20 @@ public String getOperationName() {
         return operationName;
     }
 
+    /**
+     * This is the directives that are on the operation itself and not the fields under it for example
+     * <pre>
+     * {@code
+     *   query opName @foo { field }
+     * }
+     * </pre>
+     *
+     * @return the directives that are on this operation itself.
+     */
+    public Map<String, ImmutableList<QueryAppliedDirective>> getOperationDirectives() {
+        return operationDirectives;
+    }
+
     /**
      * @return This returns how many {@link ExecutableNormalizedField}s are in the operation.
      */
diff --git a/src/main/java/graphql/normalized/ExecutableNormalizedOperationFactory.java b/src/main/java/graphql/normalized/ExecutableNormalizedOperationFactory.java
index 8501989237..8050f5154c 100644
--- a/src/main/java/graphql/normalized/ExecutableNormalizedOperationFactory.java
+++ b/src/main/java/graphql/normalized/ExecutableNormalizedOperationFactory.java
@@ -16,6 +16,8 @@
 import graphql.execution.RawVariables;
 import graphql.execution.ValuesResolver;
 import graphql.execution.conditional.ConditionalNodes;
+import graphql.execution.directives.OperationDirectivesResolver;
+import graphql.execution.directives.QueryAppliedDirective;
 import graphql.execution.directives.QueryDirectives;
 import graphql.execution.directives.QueryDirectivesImpl;
 import graphql.execution.incremental.IncrementalUtils;
@@ -449,6 +451,7 @@ private static class ExecutableNormalizedOperationFactoryImpl {
         private final CoercedVariables coercedVariableValues;
         private final @Nullable NormalizedVariables normalizedVariableValues;
         private final Options options;
+        private final OperationDirectivesResolver directivesResolver = new OperationDirectivesResolver();
 
         private final List<PossibleMerger> possibleMergerList = new ArrayList<>();
 
@@ -487,9 +490,17 @@ private ExecutableNormalizedOperation createNormalizedQueryImpl() {
                 List<ExecutableNormalizedField> childrenWithSameResultKey = possibleMerger.parent.getChildrenWithSameResultKey(possibleMerger.resultKey);
                 ENFMerger.merge(possibleMerger.parent, childrenWithSameResultKey, graphQLSchema, options.deferSupport);
             }
+
+            Map<String, ImmutableList<QueryAppliedDirective>> operationDirectives = directivesResolver.resolveDirectivesByName(operationDefinition,
+                    graphQLSchema,
+                    coercedVariableValues,
+                    options.graphQLContext,
+                    options.locale);
+
             return new ExecutableNormalizedOperation(
                     operationDefinition.getOperation(),
                     operationDefinition.getName(),
+                    operationDirectives,
                     new ArrayList<>(rootEnfs),
                     fieldToNormalizedField.build(),
                     normalizedFieldToMergedField.build(),
diff --git a/src/main/java/graphql/schema/PropertyFetchingImpl.java b/src/main/java/graphql/schema/PropertyFetchingImpl.java
index c17ba706b6..f03726b387 100644
--- a/src/main/java/graphql/schema/PropertyFetchingImpl.java
+++ b/src/main/java/graphql/schema/PropertyFetchingImpl.java
@@ -244,12 +244,51 @@ private Method findPubliclyAccessibleMethod(CacheKey cacheKey, Class<?> rootClas
                     return method;
                 }
             }
+            // Check public interfaces implemented by this class (handles non-public classes
+            // like TreeMap.Entry that implement public interfaces like Map.Entry)
+            Method method = findMethodOnPublicInterfaces(cacheKey, currentClass.getInterfaces(), methodName, dfeInUse, allowStaticMethods);
+            if (method != null) {
+                return method;
+            }
             currentClass = currentClass.getSuperclass();
         }
         assert rootClass != null;
         return rootClass.getMethod(methodName);
     }
 
+    private Method findMethodOnPublicInterfaces(CacheKey cacheKey, Class<?>[] interfaces, String methodName, boolean dfeInUse, boolean allowStaticMethods) {
+        for (Class<?> iface : interfaces) {
+            if (Modifier.isPublic(iface.getModifiers())) {
+                if (dfeInUse) {
+                    try {
+                        Method method = iface.getMethod(methodName, singleArgumentType);
+                        if (isSuitablePublicMethod(method, allowStaticMethods)) {
+                            METHOD_CACHE.putIfAbsent(cacheKey, new CachedMethod(method));
+                            return method;
+                        }
+                    } catch (NoSuchMethodException e) {
+                        // ok try the next approach
+                    }
+                }
+                try {
+                    Method method = iface.getMethod(methodName);
+                    if (isSuitablePublicMethod(method, allowStaticMethods)) {
+                        METHOD_CACHE.putIfAbsent(cacheKey, new CachedMethod(method));
+                        return method;
+                    }
+                } catch (NoSuchMethodException e) {
+                    // continue searching
+                }
+            }
+            // Also search super-interfaces of non-public interfaces
+            Method method = findMethodOnPublicInterfaces(cacheKey, iface.getInterfaces(), methodName, dfeInUse, allowStaticMethods);
+            if (method != null) {
+                return method;
+            }
+        }
+        return null;
+    }
+
     private boolean isSuitablePublicMethod(Method method, boolean allowStaticMethods) {
         int methodModifiers = method.getModifiers();
         if (Modifier.isPublic(methodModifiers)) {
diff --git a/src/main/java/graphql/schema/ShallowTypeRefCollector.java b/src/main/java/graphql/schema/ShallowTypeRefCollector.java
index d597b63b28..fa0da10414 100644
--- a/src/main/java/graphql/schema/ShallowTypeRefCollector.java
+++ b/src/main/java/graphql/schema/ShallowTypeRefCollector.java
@@ -45,6 +45,8 @@ public void handleTypeDef(GraphQLNamedType type) {
             handleObjectType((GraphQLObjectType) type);
         } else if (type instanceof GraphQLInterfaceType) {
             handleInterfaceType((GraphQLInterfaceType) type);
+        } else if (type instanceof GraphQLEnumType) {
+            handleEnumType((GraphQLEnumType) type);
         }
         // Scan applied directives on all directive container types
         if (type instanceof GraphQLDirectiveContainer) {
@@ -55,6 +57,12 @@ public void handleTypeDef(GraphQLNamedType type) {
         }
     }
 
+    private void handleEnumType(GraphQLEnumType enumType) {
+        for (GraphQLEnumValueDefinition value : enumType.getValues()) {
+            scanAppliedDirectives(value.getAppliedDirectives());
+        }
+    }
+
     private void handleObjectType(GraphQLObjectType objectType) {
         // Scan fields for type references
         for (GraphQLFieldDefinition field : objectType.getFieldDefinitions()) {
@@ -64,6 +72,7 @@ private void handleObjectType(GraphQLObjectType objectType) {
             // Scan field arguments
             for (GraphQLArgument arg : field.getArguments()) {
                 scanArgumentType(arg);
+                scanAppliedDirectives(arg.getAppliedDirectives());
             }
             // Scan applied directives on field
             scanAppliedDirectives(field.getAppliedDirectives());
@@ -98,6 +107,7 @@ private void handleInterfaceType(GraphQLInterfaceType interfaceType) {
             // Scan field arguments
             for (GraphQLArgument arg : field.getArguments()) {
                 scanArgumentType(arg);
+                scanAppliedDirectives(arg.getAppliedDirectives());
             }
             // Scan applied directives on field
             scanAppliedDirectives(field.getAppliedDirectives());
@@ -184,6 +194,7 @@ public void scanAppliedDirectives(List<GraphQLAppliedDirective> appliedDirective
     public void handleDirective(GraphQLDirective directive) {
         for (GraphQLArgument argument : directive.getArguments()) {
             scanArgumentType(argument);
+            scanAppliedDirectives(argument.getAppliedDirectives());
         }
     }
 
diff --git a/src/main/java/graphql/util/Anonymizer.java b/src/main/java/graphql/util/Anonymizer.java
index 00073f5ad6..a4929f9dd4 100644
--- a/src/main/java/graphql/util/Anonymizer.java
+++ b/src/main/java/graphql/util/Anonymizer.java
@@ -870,9 +870,13 @@ public TraversalControl visitFragmentDefinition(FragmentDefinition node, Travers
 
             @Override
             public TraversalControl visitInlineFragment(InlineFragment node, TraverserContext<Node> context) {
-                GraphQLType currentCondition = assertNotNull(schema.getType(node.getTypeCondition().getName()));
-                String newCondition = newNames.get(currentCondition);
-                return changeNode(context, node.transform(builder -> builder.typeCondition(new TypeName(newCondition))));
+                TypeName typeCondition = node.getTypeCondition();
+                if (typeCondition != null) {
+                    GraphQLType currentCondition = assertNotNull(schema.getType(typeCondition.getName()));
+                    String newCondition = newNames.get(currentCondition);
+                    return changeNode(context, node.transform(builder -> builder.typeCondition(new TypeName(newCondition))));
+                }
+                return TraversalControl.CONTINUE;
             }
 
             @Override
diff --git a/src/main/java/graphql/validation/FragmentComplexityInfo.java b/src/main/java/graphql/validation/FragmentComplexityInfo.java
new file mode 100644
index 0000000000..ae04911e75
--- /dev/null
+++ b/src/main/java/graphql/validation/FragmentComplexityInfo.java
@@ -0,0 +1,44 @@
+package graphql.validation;
+
+import graphql.Internal;
+import org.jspecify.annotations.NullMarked;
+
+/**
+ * Holds pre-calculated complexity metrics for a fragment definition.
+ * This is used to efficiently track query complexity when fragments are spread
+ * at multiple locations in a query.
+ */
+@Internal
+@NullMarked
+class FragmentComplexityInfo {
+
+    private final int fieldCount;
+    private final int maxDepth;
+
+    FragmentComplexityInfo(int fieldCount, int maxDepth) {
+        this.fieldCount = fieldCount;
+        this.maxDepth = maxDepth;
+    }
+
+    /**
+     * @return the total number of fields in this fragment, including fields from nested fragments
+     */
+    int getFieldCount() {
+        return fieldCount;
+    }
+
+    /**
+     * @return the maximum depth of fields within this fragment
+     */
+    int getMaxDepth() {
+        return maxDepth;
+    }
+
+    @Override
+    public String toString() {
+        return "FragmentComplexityInfo{" +
+                "fieldCount=" + fieldCount +
+                ", maxDepth=" + maxDepth +
+                '}';
+    }
+}
diff --git a/src/main/java/graphql/validation/GoodFaithIntrospectionExceeded.java b/src/main/java/graphql/validation/GoodFaithIntrospectionExceeded.java
new file mode 100644
index 0000000000..8da4f09d4a
--- /dev/null
+++ b/src/main/java/graphql/validation/GoodFaithIntrospectionExceeded.java
@@ -0,0 +1,45 @@
+package graphql.validation;
+
+import graphql.Internal;
+import graphql.introspection.GoodFaithIntrospection;
+import org.jspecify.annotations.NullMarked;
+
+/**
+ * Exception thrown when a good-faith introspection check fails during validation.
+ * This exception is NOT caught by the Validator — it propagates up to GraphQL.parseAndValidate()
+ * where it is converted to a {@link GoodFaithIntrospection.BadFaithIntrospectionError}.
+ */
+@Internal
+@NullMarked
+public class GoodFaithIntrospectionExceeded extends RuntimeException {
+
+    private final boolean tooBig;
+    private final String detail;
+
+    private GoodFaithIntrospectionExceeded(boolean tooBig, String detail) {
+        super(detail);
+        this.tooBig = tooBig;
+        this.detail = detail;
+    }
+
+    public static GoodFaithIntrospectionExceeded tooManyFields(String fieldCoordinate) {
+        return new GoodFaithIntrospectionExceeded(false, fieldCoordinate);
+    }
+
+    public static GoodFaithIntrospectionExceeded tooBigOperation(String message) {
+        return new GoodFaithIntrospectionExceeded(true, message);
+    }
+
+    public GoodFaithIntrospection.BadFaithIntrospectionError toBadFaithError() {
+        if (tooBig) {
+            return GoodFaithIntrospection.BadFaithIntrospectionError.tooBigOperation(detail);
+        }
+        return GoodFaithIntrospection.BadFaithIntrospectionError.tooManyFields(detail);
+    }
+
+    @Override
+    public synchronized Throwable fillInStackTrace() {
+        // No stack trace for performance - this is a control flow exception
+        return this;
+    }
+}
diff --git a/src/main/java/graphql/validation/OperationValidationRule.java b/src/main/java/graphql/validation/OperationValidationRule.java
index d5645aa5af..aa4214f0d9 100644
--- a/src/main/java/graphql/validation/OperationValidationRule.java
+++ b/src/main/java/graphql/validation/OperationValidationRule.java
@@ -184,4 +184,7 @@ public enum OperationValidationRule {
 
     /** Defer directive must not be used in subscription operations. Requires operation context. */
     DEFER_DIRECTIVE_ON_VALID_OPERATION,
+
+    /** Good faith introspection check. */
+    GOOD_FAITH_INTROSPECTION,
 }
diff --git a/src/main/java/graphql/validation/OperationValidator.java b/src/main/java/graphql/validation/OperationValidator.java
index fea8df24aa..27a1bfc18b 100644
--- a/src/main/java/graphql/validation/OperationValidator.java
+++ b/src/main/java/graphql/validation/OperationValidator.java
@@ -14,6 +14,8 @@
 import graphql.execution.TypeFromAST;
 import graphql.execution.ValuesResolver;
 import graphql.i18n.I18nMsg;
+import graphql.introspection.GoodFaithIntrospection;
+import graphql.introspection.Introspection;
 import graphql.introspection.Introspection.DirectiveLocation;
 import graphql.language.Argument;
 import graphql.language.AstComparator;
@@ -328,6 +330,20 @@ public class OperationValidator implements DocumentVisitor {
     // --- State: SubscriptionUniqueRootField ---
     private final FieldCollector fieldCollector = new FieldCollector();
 
+    // --- State: Query Complexity Limits ---
+    private int fieldCount = 0;
+    private int currentFieldDepth = 0;
+    private int maxFieldDepthSeen = 0;
+    private QueryComplexityLimits complexityLimits;
+    // Fragment complexity calculated lazily during first spread
+    private final Map<String, FragmentComplexityInfo> fragmentComplexityMap = new HashMap<>();
+    // Max depth seen during current fragment traversal (for calculating fragment's internal depth)
+    private int fragmentTraversalMaxDepth = 0;
+
+    // --- State: Good Faith Introspection ---
+    private final Map<String, Integer> introspectionFieldCounts = new HashMap<>();
+    private boolean introspectionQueryDetected = false;
+
     // --- Track whether we're in a context where fragment spread rules should run ---
     // fragmentRetraversalDepth == 0 means we're NOT inside a manually-traversed fragment => run non-fragment-spread checks
     // operationScope means we're inside an operation => can trigger fragment traversal
@@ -340,6 +356,7 @@ public OperationValidator(ValidationContext validationContext, ValidationErrorCo
         this.validationUtil = new ValidationUtil();
         this.rulePredicate = rulePredicate;
         this.allRulesEnabled = detectAllRulesEnabled(rulePredicate);
+        this.complexityLimits = validationContext.getQueryComplexityLimits();
         prepareFragmentSpreadsMap();
     }
 
@@ -388,6 +405,37 @@ private boolean shouldRunOperationScopedRules() {
         return operationScope;
     }
 
+    // ==================== Query Complexity Limit Helpers ====================
+
+    private void checkFieldCountLimit() {
+        if (fieldCount > complexityLimits.getMaxFieldsCount()) {
+            if (introspectionQueryDetected) {
+                throw GoodFaithIntrospectionExceeded.tooBigOperation(
+                        "Query has " + fieldCount + " fields which exceeds maximum allowed " + complexityLimits.getMaxFieldsCount());
+            }
+            throw new QueryComplexityLimitsExceeded(
+                    ValidationErrorType.MaxQueryFieldsExceeded,
+                    complexityLimits.getMaxFieldsCount(),
+                    fieldCount);
+        }
+    }
+
+    private void checkDepthLimit(int depth) {
+        if (depth > maxFieldDepthSeen) {
+            maxFieldDepthSeen = depth;
+            if (maxFieldDepthSeen > complexityLimits.getMaxDepth()) {
+                if (introspectionQueryDetected) {
+                    throw GoodFaithIntrospectionExceeded.tooBigOperation(
+                            "Query depth " + maxFieldDepthSeen + " exceeds maximum allowed depth " + complexityLimits.getMaxDepth());
+                }
+                throw new QueryComplexityLimitsExceeded(
+                        ValidationErrorType.MaxQueryDepthExceeded,
+                        complexityLimits.getMaxDepth(),
+                        maxFieldDepthSeen);
+            }
+        }
+    }
+
     @Override
     public void enter(Node node, List<Node> ancestors) {
         validationContext.getTraversalContext().enter(node, ancestors);
@@ -401,6 +449,17 @@ public void enter(Node node, List<Node> ancestors) {
         } else if (node instanceof VariableDefinition) {
             checkVariableDefinition((VariableDefinition) node);
         } else if (node instanceof Field) {
+            // Track complexity only during operation scope
+            if (operationScope) {
+                fieldCount++;
+                currentFieldDepth++;
+                checkFieldCountLimit();
+                checkDepthLimit(currentFieldDepth);
+                // Track max depth during fragment traversal for storing later
+                if (fragmentRetraversalDepth > 0 && currentFieldDepth > fragmentTraversalMaxDepth) {
+                    fragmentTraversalMaxDepth = currentFieldDepth;
+                }
+            }
             checkField((Field) node);
         } else if (node instanceof InlineFragment) {
             checkInlineFragment((InlineFragment) node);
@@ -433,6 +492,10 @@ public void leave(Node node, List<Node> ancestors) {
             leaveSelectionSet();
         } else if (node instanceof FragmentDefinition) {
             leaveFragmentDefinition();
+        } else if (node instanceof Field) {
+            if (operationScope) {
+                currentFieldDepth--;
+            }
         }
     }
 
@@ -554,6 +617,53 @@ private void checkField(Field field) {
                 validateUniqueDirectiveNamesPerLocation(field, field.getDirectives());
             }
         }
+        // Good Faith Introspection: runs during fragment spread traversal too (operationScope)
+        if (operationScope && isRuleEnabled(OperationValidationRule.GOOD_FAITH_INTROSPECTION)) {
+            checkGoodFaithIntrospection(field);
+        }
+    }
+
+    // --- GoodFaithIntrospection ---
+    private void checkGoodFaithIntrospection(Field field) {
+        GraphQLCompositeType parentType = validationContext.getParentType();
+        if (parentType == null) {
+            return;
+        }
+        String fieldName = field.getName();
+        String key = null;
+
+        // Check query-level introspection fields (__schema, __type).
+        // Only counted at the structural level (not during fragment traversal) to match ENO merging
+        // behavior where the same field from a direct selection and a fragment spread merge into one.
+        if (shouldRunDocumentLevelRules()) {
+            GraphQLObjectType queryType = validationContext.getSchema().getQueryType();
+            if (parentType.getName().equals(queryType.getName())) {
+                if (Introspection.SchemaMetaFieldDef.getName().equals(fieldName) || Introspection.TypeMetaFieldDef.getName().equals(fieldName)) {
+                    key = parentType.getName() + "." + fieldName;
+                    if (!introspectionQueryDetected) {
+                        introspectionQueryDetected = true;
+                        complexityLimits = GoodFaithIntrospection.goodFaithLimits(complexityLimits);
+                    }
+                }
+            }
+        }
+
+        // Check __Type fields that can form cycles.
+        // Counted during ALL traversals (including fragment spreads) because each occurrence
+        // at a different depth represents a separate cycle risk.
+        if (Introspection.__Type.getName().equals(parentType.getName())) {
+            if ("fields".equals(fieldName) || "inputFields".equals(fieldName)
+                    || "interfaces".equals(fieldName) || "possibleTypes".equals(fieldName)) {
+                key = "__Type." + fieldName;
+            }
+        }
+
+        if (key != null) {
+            int count = introspectionFieldCounts.merge(key, 1, Integer::sum);
+            if (count > 1) {
+                throw GoodFaithIntrospectionExceeded.tooManyFields(key);
+            }
+        }
     }
 
     private void checkInlineFragment(InlineFragment inlineFragment) {
@@ -611,14 +721,50 @@ private void checkFragmentSpread(FragmentSpread node, List<Node> ancestors) {
             }
         }
 
-        // Manually traverse into fragment definition during operation scope
+        // Handle complexity tracking and fragment traversal
         if (operationScope) {
-            FragmentDefinition fragment = validationContext.getFragment(node.getName());
-            if (fragment != null && !visitedFragmentSpreads.contains(node.getName())) {
-                visitedFragmentSpreads.add(node.getName());
+            String fragmentName = node.getName();
+            FragmentDefinition fragment = validationContext.getFragment(fragmentName);
+
+            if (visitedFragmentSpreads.contains(fragmentName)) {
+                // Subsequent spread - add stored complexity (don't traverse again)
+                FragmentComplexityInfo info = fragmentComplexityMap.get(fragmentName);
+                if (info != null) {
+                    fieldCount += info.getFieldCount();
+                    checkFieldCountLimit();
+                    int potentialDepth = currentFieldDepth + info.getMaxDepth();
+                    checkDepthLimit(potentialDepth);
+                    // Update max depth if we're inside a fragment traversal
+                    if (fragmentRetraversalDepth > 0 && potentialDepth > fragmentTraversalMaxDepth) {
+                        fragmentTraversalMaxDepth = potentialDepth;
+                    }
+                }
+            } else if (fragment != null) {
+                // First spread - traverse and track complexity
+                visitedFragmentSpreads.add(fragmentName);
+
+                int fieldCountBefore = fieldCount;
+                int depthAtEntry = currentFieldDepth;
+                int previousFragmentMaxDepth = fragmentTraversalMaxDepth;
+
+                // Initialize max depth tracking for this fragment
+                fragmentTraversalMaxDepth = currentFieldDepth;
+
                 fragmentRetraversalDepth++;
                 new LanguageTraversal(ancestors).traverse(fragment, this);
                 fragmentRetraversalDepth--;
+
+                // Calculate and store fragment complexity
+                int fragmentFieldCount = fieldCount - fieldCountBefore;
+                int fragmentMaxInternalDepth = fragmentTraversalMaxDepth - depthAtEntry;
+
+                fragmentComplexityMap.put(fragmentName,
+                        new FragmentComplexityInfo(fragmentFieldCount, fragmentMaxInternalDepth));
+
+                // Restore max depth for outer fragment (if nested)
+                if (fragmentRetraversalDepth > 0 && previousFragmentMaxDepth > fragmentTraversalMaxDepth) {
+                    fragmentTraversalMaxDepth = previousFragmentMaxDepth;
+                }
             }
         }
     }
@@ -724,6 +870,13 @@ private void leaveOperationDefinition() {
                 }
             }
         }
+
+        // Reset complexity counters for next operation
+        fieldCount = 0;
+        currentFieldDepth = 0;
+        maxFieldDepthSeen = 0;
+        fragmentTraversalMaxDepth = 0;
+        introspectionFieldCounts.clear();
     }
 
     private void leaveSelectionSet() {
@@ -1241,8 +1394,8 @@ private boolean sameArguments(List<Argument> arguments1, @Nullable List<Argument
             }
             GraphQLType typeA = typeAOriginal;
             GraphQLType typeB = fieldAndType.graphQLType;
-            if (typeB == null) {
-                return mkNotSameTypeError(path, fields, typeA, typeB);
+            if (typeA == null || typeB == null) {
+                continue;
             }
             while (true) {
                 if (isNonNull(typeA) || isNonNull(typeB)) {
@@ -1557,7 +1710,7 @@ private void validateUniqueOperationNames(OperationDefinition operationDefinitio
             return;
         }
         if (operationNames.contains(name)) {
-            String message = i18n(DuplicateOperationName, "UniqueOperationNames.oneOperation", operationDefinition.getName());
+            String message = i18n(DuplicateOperationName, "UniqueOperationNames.oneOperation", name);
             addError(DuplicateOperationName, operationDefinition.getSourceLocation(), message);
         } else {
             operationNames.add(name);
@@ -1648,12 +1801,12 @@ private void validateSubscriptionUniqueRootField(OperationDefinition operationDe
                     .build();
             MergedSelectionSet fields = fieldCollector.collectFields(collectorParameters, operationDef.getSelectionSet());
             if (fields.size() > 1) {
-                String message = i18n(SubscriptionMultipleRootFields, "SubscriptionUniqueRootField.multipleRootFields", operationDef.getName());
+                String message = i18n(SubscriptionMultipleRootFields, "SubscriptionUniqueRootField.multipleRootFields", Objects.toString(operationDef.getName(), ""));
                 addError(SubscriptionMultipleRootFields, operationDef.getSourceLocation(), message);
             } else {
                 MergedField mergedField = fields.getSubFieldsList().get(0);
                 if (isIntrospectionField(mergedField)) {
-                    String message = i18n(SubscriptionIntrospectionRootField, "SubscriptionIntrospectionRootField.introspectionRootField", operationDef.getName(), mergedField.getName());
+                    String message = i18n(SubscriptionIntrospectionRootField, "SubscriptionIntrospectionRootField.introspectionRootField", Objects.toString(operationDef.getName(), ""), mergedField.getName());
                     addError(SubscriptionIntrospectionRootField, mergedField.getSingleField().getSourceLocation(), message);
                 }
             }
diff --git a/src/main/java/graphql/validation/QueryComplexityLimits.java b/src/main/java/graphql/validation/QueryComplexityLimits.java
new file mode 100644
index 0000000000..f46020cedf
--- /dev/null
+++ b/src/main/java/graphql/validation/QueryComplexityLimits.java
@@ -0,0 +1,171 @@
+package graphql.validation;
+
+import graphql.PublicApi;
+import org.jspecify.annotations.NullMarked;
+
+/**
+ * Configuration class for query complexity limits enforced during validation.
+ * This provides a lightweight alternative to ExecutableNormalizedOperation (ENO) for tracking
+ * query depth and field count.
+ *
+ * <p>By default, validation enforces limits (maxDepth=100, maxFieldsCount=100000).
+ * To customize limits per-request, put a custom instance in the GraphQLContext:
+ * <pre>{@code
+ * QueryComplexityLimits limits = QueryComplexityLimits.newLimits()
+ *     .maxDepth(10)
+ *     .maxFieldsCount(100)
+ *     .build();
+ *
+ * ExecutionInput executionInput = ExecutionInput.newExecutionInput()
+ *     .query(query)
+ *     .graphQLContext(ctx -> ctx.put(QueryComplexityLimits.KEY, limits))
+ *     .build();
+ * }</pre>
+ *
+ * <p>To disable limits for a request, use {@link #NONE}:
+ * <pre>{@code
+ * executionInput.getGraphQLContext().put(QueryComplexityLimits.KEY, QueryComplexityLimits.NONE);
+ * }</pre>
+ *
+ * <p>To change the default limits globally (e.g., for testing), use {@link #setDefaultLimits(QueryComplexityLimits)}:
+ * <pre>{@code
+ * QueryComplexityLimits.setDefaultLimits(QueryComplexityLimits.NONE); // disable for tests
+ * }</pre>
+ */
+@PublicApi
+@NullMarked
+public class QueryComplexityLimits {
+
+    /**
+     * Default maximum query depth.
+     */
+    public static final int DEFAULT_MAX_DEPTH = 100;
+
+    /**
+     * Default maximum field count.
+     */
+    public static final int DEFAULT_MAX_FIELDS_COUNT = 100_000;
+
+    /**
+     * The key used to store QueryComplexityLimits in GraphQLContext.
+     */
+    public static final String KEY = "graphql.validation.QueryComplexityLimits";
+
+    /**
+     * Standard limits (maxDepth=100, maxFieldsCount=100000).
+     */
+    public static final QueryComplexityLimits DEFAULT = new QueryComplexityLimits(DEFAULT_MAX_DEPTH, DEFAULT_MAX_FIELDS_COUNT);
+
+    /**
+     * No limits (all limits set to Integer.MAX_VALUE). Use this to disable complexity checking.
+     */
+    public static final QueryComplexityLimits NONE = new QueryComplexityLimits(Integer.MAX_VALUE, Integer.MAX_VALUE);
+
+    private static volatile QueryComplexityLimits defaultLimits = DEFAULT;
+
+    /**
+     * Sets the default limits used when no limits are specified in GraphQLContext.
+     * This is useful for testing or for applications that want different global defaults.
+     *
+     * @param limits the default limits to use (use {@link #NONE} to disable, {@link #DEFAULT} to restore)
+     */
+    public static void setDefaultLimits(QueryComplexityLimits limits) {
+        defaultLimits = limits;
+    }
+
+    /**
+     * Returns the current default limits.
+     *
+     * @return the default limits
+     */
+    public static QueryComplexityLimits getDefaultLimits() {
+        return defaultLimits;
+    }
+
+    private final int maxDepth;
+    private final int maxFieldsCount;
+
+    private QueryComplexityLimits(int maxDepth, int maxFieldsCount) {
+        this.maxDepth = maxDepth;
+        this.maxFieldsCount = maxFieldsCount;
+    }
+
+    /**
+     * @return the maximum allowed depth for queries, where depth is measured as the number of nested Field nodes
+     */
+    public int getMaxDepth() {
+        return maxDepth;
+    }
+
+    /**
+     * @return the maximum allowed number of fields in a query, counting fields at each fragment spread site
+     */
+    public int getMaxFieldsCount() {
+        return maxFieldsCount;
+    }
+
+    /**
+     * @return a new builder for creating QueryComplexityLimits
+     */
+    public static Builder newLimits() {
+        return new Builder();
+    }
+
+    @Override
+    public String toString() {
+        return "QueryComplexityLimits{" +
+                "maxDepth=" + maxDepth +
+                ", maxFieldsCount=" + maxFieldsCount +
+                '}';
+    }
+
+    /**
+     * Builder for QueryComplexityLimits.
+     */
+    @PublicApi
+    @NullMarked
+    public static class Builder {
+        private int maxDepth = Integer.MAX_VALUE;
+        private int maxFieldsCount = Integer.MAX_VALUE;
+
+        private Builder() {
+        }
+
+        /**
+         * Sets the maximum allowed depth for queries.
+         * Depth is measured as the number of nested Field nodes.
+         *
+         * @param maxDepth the maximum depth (must be positive)
+         * @return this builder
+         */
+        public Builder maxDepth(int maxDepth) {
+            if (maxDepth <= 0) {
+                throw new IllegalArgumentException("maxDepth must be positive");
+            }
+            this.maxDepth = maxDepth;
+            return this;
+        }
+
+        /**
+         * Sets the maximum allowed number of fields in a query.
+         * Fields inside fragments are counted at each spread site.
+         *
+         * @param maxFieldsCount the maximum field count (must be positive)
+         * @return this builder
+         */
+        public Builder maxFieldsCount(int maxFieldsCount) {
+            if (maxFieldsCount <= 0) {
+                throw new IllegalArgumentException("maxFieldsCount must be positive");
+            }
+            this.maxFieldsCount = maxFieldsCount;
+            return this;
+        }
+
+        /**
+         * @return a new QueryComplexityLimits instance
+         */
+        public QueryComplexityLimits build() {
+            return new QueryComplexityLimits(maxDepth, maxFieldsCount);
+        }
+    }
+}
diff --git a/src/main/java/graphql/validation/QueryComplexityLimitsExceeded.java b/src/main/java/graphql/validation/QueryComplexityLimitsExceeded.java
new file mode 100644
index 0000000000..adaffba2af
--- /dev/null
+++ b/src/main/java/graphql/validation/QueryComplexityLimitsExceeded.java
@@ -0,0 +1,42 @@
+package graphql.validation;
+
+import graphql.Internal;
+import org.jspecify.annotations.NullMarked;
+
+/**
+ * Exception thrown when query complexity limits (depth or field count) are exceeded during validation.
+ * This exception is caught by the Validator and converted to a ValidationError.
+ */
+@Internal
+@NullMarked
+public class QueryComplexityLimitsExceeded extends RuntimeException {
+
+    private final ValidationErrorType errorType;
+    private final int limit;
+    private final int actual;
+
+    public QueryComplexityLimitsExceeded(ValidationErrorType errorType, int limit, int actual) {
+        super(errorType.name() + ": limit=" + limit + ", actual=" + actual);
+        this.errorType = errorType;
+        this.limit = limit;
+        this.actual = actual;
+    }
+
+    public ValidationErrorType getErrorType() {
+        return errorType;
+    }
+
+    public int getLimit() {
+        return limit;
+    }
+
+    public int getActual() {
+        return actual;
+    }
+
+    @Override
+    public synchronized Throwable fillInStackTrace() {
+        // No stack trace for performance - this is a control flow exception
+        return this;
+    }
+}
diff --git a/src/main/java/graphql/validation/ValidationContext.java b/src/main/java/graphql/validation/ValidationContext.java
index 873783785f..9440931027 100644
--- a/src/main/java/graphql/validation/ValidationContext.java
+++ b/src/main/java/graphql/validation/ValidationContext.java
@@ -33,13 +33,19 @@ public class ValidationContext {
     private final Map<String, FragmentDefinition> fragmentDefinitionMap = new LinkedHashMap<>();
     private final I18n i18n;
     private final GraphQLContext graphQLContext;
+    private final QueryComplexityLimits queryComplexityLimits;
 
     public ValidationContext(GraphQLSchema schema, Document document, I18n i18n) {
+        this(schema, document, i18n, null);
+    }
+
+    public ValidationContext(GraphQLSchema schema, Document document, I18n i18n, @Nullable QueryComplexityLimits limits) {
         this.schema = schema;
         this.document = document;
         this.traversalContext = new TraversalContext(schema);
         this.i18n = i18n;
         this.graphQLContext = GraphQLContext.newContext().of(Locale.class, i18n.getLocale()).build();
+        this.queryComplexityLimits = limits != null ? limits : QueryComplexityLimits.getDefaultLimits();
         buildFragmentMap();
     }
 
@@ -109,6 +115,10 @@ public GraphQLContext getGraphQLContext() {
         return graphQLContext;
     }
 
+    public QueryComplexityLimits getQueryComplexityLimits() {
+        return queryComplexityLimits;
+    }
+
     /**
      * Creates an I18N message using the key and arguments
      *
diff --git a/src/main/java/graphql/validation/ValidationErrorType.java b/src/main/java/graphql/validation/ValidationErrorType.java
index 59d5c3ac0f..afd75cda54 100644
--- a/src/main/java/graphql/validation/ValidationErrorType.java
+++ b/src/main/java/graphql/validation/ValidationErrorType.java
@@ -45,5 +45,7 @@ public enum ValidationErrorType implements ValidationErrorClassification {
     SubscriptionMultipleRootFields,
     SubscriptionIntrospectionRootField,
     UniqueObjectFieldName,
-    UnknownOperation
+    UnknownOperation,
+    MaxQueryDepthExceeded,
+    MaxQueryFieldsExceeded
 }
diff --git a/src/main/java/graphql/validation/Validator.java b/src/main/java/graphql/validation/Validator.java
index 654eec5cef..d6237bf131 100644
--- a/src/main/java/graphql/validation/Validator.java
+++ b/src/main/java/graphql/validation/Validator.java
@@ -37,8 +37,12 @@ public List<ValidationError> validateDocument(GraphQLSchema schema, Document doc
     }
 
     public List<ValidationError> validateDocument(GraphQLSchema schema, Document document, Predicate<OperationValidationRule> rulePredicate, Locale locale) {
+        return validateDocument(schema, document, rulePredicate, locale, null);
+    }
+
+    public List<ValidationError> validateDocument(GraphQLSchema schema, Document document, Predicate<OperationValidationRule> rulePredicate, Locale locale, QueryComplexityLimits limits) {
         I18n i18n = I18n.i18n(I18n.BundleType.Validation, locale);
-        ValidationContext validationContext = new ValidationContext(schema, document, i18n);
+        ValidationContext validationContext = new ValidationContext(schema, document, i18n, limits);
 
         ValidationErrorCollector validationErrorCollector = new ValidationErrorCollector(MAX_VALIDATION_ERRORS);
         OperationValidator operationValidator = new OperationValidator(validationContext, validationErrorCollector, rulePredicate);
@@ -47,6 +51,12 @@ public List<ValidationError> validateDocument(GraphQLSchema schema, Document doc
             languageTraversal.traverse(document, operationValidator);
         } catch (ValidationErrorCollector.MaxValidationErrorsReached ignored) {
             // if we have generated enough errors, then we can shortcut out
+        } catch (QueryComplexityLimitsExceeded e) {
+            String message = i18n.msg(e.getErrorType().name() + ".message", e.getLimit(), e.getActual());
+            validationErrorCollector.addError(ValidationError.newValidationError()
+                    .validationErrorType(e.getErrorType())
+                    .description(message)
+                    .build());
         }
 
         return validationErrorCollector.getErrors();
diff --git a/src/main/resources/i18n/Validation.properties b/src/main/resources/i18n/Validation.properties
index a9403bea5b..8f2ad5715c 100644
--- a/src/main/resources/i18n/Validation.properties
+++ b/src/main/resources/i18n/Validation.properties
@@ -110,4 +110,7 @@ ArgumentValidationUtil.handleMissingFieldsError=Validation error ({0}) : argumen
 ArgumentValidationUtil.handleExtraFieldError=Validation error ({0}) : argument ''{1}'' with value ''{2}'' contains a field not in ''{3}'': ''{4}''
 # suppress inspection "UnusedProperty"
 # suppress inspection "UnusedMessageFormatParameter"
-ArgumentValidationUtil.extraOneOfFieldsError=Validation error ({0}) : Exactly one key must be specified for OneOf type ''{3}''.
\ No newline at end of file
+ArgumentValidationUtil.extraOneOfFieldsError=Validation error ({0}) : Exactly one key must be specified for OneOf type ''{3}''.
+#
+MaxQueryDepthExceeded.message=Query depth {1} exceeds maximum allowed depth {0}
+MaxQueryFieldsExceeded.message=Query has {1} fields which exceeds maximum allowed {0}
\ No newline at end of file
diff --git a/src/test/groovy/graphql/analysis/QueryTraverserTest.groovy b/src/test/groovy/graphql/analysis/QueryTraverserTest.groovy
index dbe0b33384..15cf09faec 100644
--- a/src/test/groovy/graphql/analysis/QueryTraverserTest.groovy
+++ b/src/test/groovy/graphql/analysis/QueryTraverserTest.groovy
@@ -1525,14 +1525,14 @@ class QueryTraverserTest extends Specification {
 
         where:
         document             | operationName | root                     | rootParentType          | fragmentsByName
-        createQuery("{foo}") | null          | Field.newField().build() | null                    | null
-        createQuery("{foo}") | "foo"         | Field.newField().build() | null                    | null
-        createQuery("{foo}") | "foo"         | Field.newField().build() | Mock(GraphQLObjectType) | null
-        createQuery("{foo}") | "foo"         | Field.newField().build() | null                    | emptyMap()
-        null                 | "foo"         | Field.newField().build() | Mock(GraphQLObjectType) | null
-        null                 | "foo"         | Field.newField().build() | Mock(GraphQLObjectType) | emptyMap()
-        null                 | "foo"         | Field.newField().build() | Mock(GraphQLObjectType) | emptyMap()
-        null                 | "foo"         | Field.newField().build() | null                    | emptyMap()
+        createQuery("{foo}") | null          | Field.newField().name("dummy").build() | null                    | null
+        createQuery("{foo}") | "foo"         | Field.newField().name("dummy").build() | null                    | null
+        createQuery("{foo}") | "foo"         | Field.newField().name("dummy").build() | Mock(GraphQLObjectType) | null
+        createQuery("{foo}") | "foo"         | Field.newField().name("dummy").build() | null                    | emptyMap()
+        null                 | "foo"         | Field.newField().name("dummy").build() | Mock(GraphQLObjectType) | null
+        null                 | "foo"         | Field.newField().name("dummy").build() | Mock(GraphQLObjectType) | emptyMap()
+        null                 | "foo"         | Field.newField().name("dummy").build() | Mock(GraphQLObjectType) | emptyMap()
+        null                 | "foo"         | Field.newField().name("dummy").build() | null                    | emptyMap()
         null                 | "foo"         | null                     | Mock(GraphQLObjectType) | emptyMap()
         null                 | "foo"         | null                     | Mock(GraphQLObjectType) | null
         null                 | "foo"         | null                     | null                    | emptyMap()
@@ -1544,7 +1544,7 @@ class QueryTraverserTest extends Specification {
         QueryTraverser.newQueryTraverser()
                 .document(createQuery("{foo}"))
                 .operationName("foo")
-                .root(Field.newField().build())
+                .root(Field.newField().name("dummy").build())
                 .rootParentType(Mock(GraphQLObjectType))
                 .fragmentsByName(emptyMap())
                 .build()
diff --git a/src/test/groovy/graphql/archunit/JSpecifyAnnotationsCheck.groovy b/src/test/groovy/graphql/archunit/JSpecifyAnnotationsCheck.groovy
index 1b6cdafa61..8672329248 100644
--- a/src/test/groovy/graphql/archunit/JSpecifyAnnotationsCheck.groovy
+++ b/src/test/groovy/graphql/archunit/JSpecifyAnnotationsCheck.groovy
@@ -11,83 +11,7 @@ import spock.lang.Specification
 class JSpecifyAnnotationsCheck extends Specification {
 
     private static final Set<String> JSPECIFY_EXEMPTION_LIST = [
-            "graphql.analysis.QueryComplexityCalculator",
-            "graphql.analysis.QueryComplexityInfo",
-            "graphql.analysis.QueryDepthInfo",
-            "graphql.analysis.QueryReducer",
-            "graphql.analysis.QueryTransformer",
-            "graphql.analysis.QueryTraversalOptions",
             "graphql.analysis.QueryTraverser",
-            "graphql.analysis.QueryVisitor",
-            "graphql.analysis.QueryVisitorFieldArgumentEnvironment",
-            "graphql.analysis.QueryVisitorFieldArgumentInputValue",
-            "graphql.analysis.QueryVisitorFieldArgumentValueEnvironment",
-            "graphql.analysis.QueryVisitorFieldEnvironment",
-            "graphql.analysis.QueryVisitorFragmentDefinitionEnvironment",
-            "graphql.analysis.QueryVisitorFragmentSpreadEnvironment",
-            "graphql.analysis.QueryVisitorInlineFragmentEnvironment",
-            "graphql.analysis.QueryVisitorStub",
-            "graphql.analysis.values.ValueTraverser",
-            "graphql.execution.AbortExecutionException",
-            "graphql.execution.AsyncExecutionStrategy",
-            "graphql.execution.AsyncSerialExecutionStrategy",
-            "graphql.execution.CoercedVariables",
-            "graphql.execution.DataFetcherExceptionHandlerParameters",
-            "graphql.execution.DataFetcherExceptionHandlerResult",
-            "graphql.execution.DefaultValueUnboxer",
-            "graphql.execution.ExecutionContext",
-            "graphql.execution.ExecutionId",
-            "graphql.execution.ExecutionStepInfo",
-            "graphql.execution.ExecutionStrategyParameters",
-            "graphql.execution.FetchedValue",
-            "graphql.execution.FieldValueInfo",
-            "graphql.execution.InputMapDefinesTooManyFieldsException",
-            "graphql.execution.MergedSelectionSet",
-            "graphql.execution.MissingRootTypeException",
-            "graphql.execution.NonNullableValueCoercedAsNullException",
-            "graphql.execution.NormalizedVariables",
-            "graphql.execution.OneOfNullValueException",
-            "graphql.execution.OneOfTooManyKeysException",
-            "graphql.execution.ResultNodesInfo",
-            "graphql.execution.ResultPath",
-            "graphql.execution.SimpleDataFetcherExceptionHandler",
-            "graphql.execution.SubscriptionExecutionStrategy",
-            "graphql.execution.UnknownOperationException",
-            "graphql.execution.UnresolvedTypeException",
-            "graphql.execution.conditional.ConditionalNodeDecision",
-            "graphql.execution.directives.QueryAppliedDirective",
-            "graphql.execution.directives.QueryAppliedDirectiveArgument",
-            "graphql.execution.directives.QueryDirectives",
-            "graphql.execution.incremental.DeferredExecution",
-            "graphql.execution.instrumentation.ChainedInstrumentation",
-            "graphql.execution.instrumentation.DocumentAndVariables",
-            "graphql.execution.instrumentation.NoContextChainedInstrumentation",
-            "graphql.execution.ResponseMapFactory",
-            "graphql.execution.instrumentation.SimpleInstrumentation",
-            "graphql.execution.instrumentation.SimpleInstrumentationContext",
-            "graphql.execution.instrumentation.SimplePerformantInstrumentation",
-            "graphql.execution.instrumentation.fieldvalidation.FieldAndArguments",
-            "graphql.execution.instrumentation.fieldvalidation.FieldValidationEnvironment",
-            "graphql.execution.instrumentation.fieldvalidation.FieldValidationInstrumentation",
-            "graphql.execution.instrumentation.fieldvalidation.SimpleFieldValidation",
-            "graphql.execution.instrumentation.parameters.InstrumentationCreateStateParameters",
-            "graphql.execution.instrumentation.parameters.InstrumentationExecuteOperationParameters",
-            "graphql.execution.instrumentation.parameters.InstrumentationExecutionParameters",
-            "graphql.execution.instrumentation.parameters.InstrumentationExecutionStrategyParameters",
-            "graphql.execution.instrumentation.parameters.InstrumentationFieldCompleteParameters",
-            "graphql.execution.instrumentation.parameters.InstrumentationFieldFetchParameters",
-            "graphql.execution.instrumentation.parameters.InstrumentationFieldParameters",
-            "graphql.execution.instrumentation.parameters.InstrumentationValidationParameters",
-            "graphql.execution.instrumentation.tracing.TracingInstrumentation",
-            "graphql.execution.instrumentation.tracing.TracingSupport",
-            "graphql.execution.preparsed.PreparsedDocumentEntry",
-            "graphql.execution.preparsed.persisted.ApolloPersistedQuerySupport",
-            "graphql.execution.preparsed.persisted.InMemoryPersistedQueryCache",
-            "graphql.execution.preparsed.persisted.PersistedQueryCacheMiss",
-            "graphql.execution.preparsed.persisted.PersistedQueryIdInvalid",
-            "graphql.execution.preparsed.persisted.PersistedQueryNotFound",
-            "graphql.execution.reactive.DelegatingSubscription",
-            "graphql.execution.reactive.SubscriptionPublisher",
             "graphql.extensions.ExtensionsBuilder",
             "graphql.incremental.DeferPayload",
             "graphql.incremental.DelayedIncrementalPartialResult",
@@ -96,62 +20,12 @@ class JSpecifyAnnotationsCheck extends Specification {
             "graphql.incremental.IncrementalExecutionResultImpl",
             "graphql.incremental.IncrementalPayload",
             "graphql.incremental.StreamPayload",
-            "graphql.introspection.GoodFaithIntrospection",
             "graphql.introspection.Introspection",
             "graphql.introspection.IntrospectionQuery",
             "graphql.introspection.IntrospectionQueryBuilder",
             "graphql.introspection.IntrospectionResultToSchema",
             "graphql.introspection.IntrospectionWithDirectivesSupport",
             "graphql.introspection.IntrospectionWithDirectivesSupport\$DirectivePredicateEnvironment",
-            "graphql.language.AbstractDescribedNode",
-            "graphql.language.AstNodeAdapter",
-            "graphql.language.AstPrinter",
-            "graphql.language.AstSignature",
-            "graphql.language.AstSorter",
-            "graphql.language.AstTransformer",
-            "graphql.language.Comment",
-            "graphql.language.Definition",
-            "graphql.language.DescribedNode",
-            "graphql.language.Description",
-            "graphql.language.Directive",
-            "graphql.language.DirectiveDefinition",
-            "graphql.language.DirectiveLocation",
-            "graphql.language.DirectivesContainer",
-            "graphql.language.Document",
-            "graphql.language.EnumTypeDefinition",
-            "graphql.language.EnumTypeExtensionDefinition",
-            "graphql.language.EnumValueDefinition",
-            "graphql.language.Field",
-            "graphql.language.FieldDefinition",
-            "graphql.language.FragmentDefinition",
-            "graphql.language.FragmentSpread",
-            "graphql.language.IgnoredChar",
-            "graphql.language.IgnoredChars",
-            "graphql.language.ImplementingTypeDefinition",
-            "graphql.language.InlineFragment",
-            "graphql.language.InputObjectTypeDefinition",
-            "graphql.language.InputObjectTypeExtensionDefinition",
-            "graphql.language.InputValueDefinition",
-            "graphql.language.InterfaceTypeDefinition",
-            "graphql.language.InterfaceTypeExtensionDefinition",
-            "graphql.language.ListType",
-            "graphql.language.Node",
-            "graphql.language.NodeChildrenContainer",
-            "graphql.language.NodeDirectivesBuilder",
-            "graphql.language.NodeParentTree",
-            "graphql.language.NodeTraverser",
-            "graphql.language.NodeVisitor",
-            "graphql.language.NodeVisitorStub",
-            "graphql.language.NonNullType",
-            "graphql.language.ObjectField",
-            "graphql.language.ObjectTypeDefinition",
-            "graphql.language.ObjectTypeExtensionDefinition",
-            "graphql.language.OperationDefinition",
-            "graphql.language.OperationTypeDefinition",
-            "graphql.language.PrettyAstPrinter",
-            "graphql.language.SDLDefinition",
-            "graphql.language.SDLExtensionDefinition",
-            "graphql.language.SDLNamedDefinition",
             "graphql.language.ScalarTypeDefinition",
             "graphql.language.ScalarTypeExtensionDefinition",
             "graphql.language.SchemaDefinition",
@@ -159,9 +33,6 @@ class JSpecifyAnnotationsCheck extends Specification {
             "graphql.language.Selection",
             "graphql.language.SelectionSet",
             "graphql.language.SelectionSetContainer",
-            "graphql.language.SourceLocation",
-            "graphql.language.Type",
-            "graphql.language.TypeDefinition",
             "graphql.language.TypeKind",
             "graphql.language.TypeName",
             "graphql.language.UnionTypeDefinition",
diff --git a/src/test/groovy/graphql/execution/ExecutionStrategyTest.groovy b/src/test/groovy/graphql/execution/ExecutionStrategyTest.groovy
index 71eee4f284..ab051e121c 100644
--- a/src/test/groovy/graphql/execution/ExecutionStrategyTest.groovy
+++ b/src/test/groovy/graphql/execution/ExecutionStrategyTest.groovy
@@ -140,9 +140,9 @@ class ExecutionStrategyTest extends Specification {
         def parameters = newParameters()
                 .executionStepInfo(ExecutionStepInfo.newExecutionStepInfo().type(objectType))
                 .source(result)
-                .fields(mergedSelectionSet(["fld": [Field.newField().build()]]))
+                .fields(mergedSelectionSet(["fld": [Field.newField().name("dummy").build()]]))
                 .nonNullFieldValidator(new NonNullableFieldValidator(executionContext))
-                .field(mergedField(Field.newField().build()))
+                .field(mergedField(Field.newField().name("dummy").build()))
                 .build()
 
         when:
@@ -770,8 +770,8 @@ class ExecutionStrategyTest extends Specification {
                 .executionStepInfo(executionStepInfo)
                 .source(result)
                 .nonNullFieldValidator(nullableFieldValidator)
-                .fields(mergedSelectionSet(["fld": [mergedField(Field.newField().build())]]))
-                .field(mergedField(Field.newField().build()))
+                .fields(mergedSelectionSet(["fld": [mergedField(Field.newField().name("dummy").build())]]))
+                .field(mergedField(Field.newField().name("dummy").build()))
                 .build()
 
         when:
@@ -794,8 +794,8 @@ class ExecutionStrategyTest extends Specification {
                 .executionStepInfo(executionStepInfo)
                 .source(result)
                 .nonNullFieldValidator(nullableFieldValidator)
-                .fields(mergedSelectionSet(["fld": [mergedField(Field.newField().build())]]))
-                .field(mergedField(Field.newField().build()))
+                .fields(mergedSelectionSet(["fld": [mergedField(Field.newField().name("dummy").build())]]))
+                .field(mergedField(Field.newField().name("dummy").build()))
                 .build()
 
         when:
@@ -818,8 +818,8 @@ class ExecutionStrategyTest extends Specification {
                 .executionStepInfo(executionStepInfo)
                 .source(result)
                 .nonNullFieldValidator(nullableFieldValidator)
-                .fields(mergedSelectionSet(["fld": [mergedField(Field.newField().build())]]))
-                .field(mergedField(Field.newField().build()))
+                .fields(mergedSelectionSet(["fld": [mergedField(Field.newField().name("dummy").build())]]))
+                .field(mergedField(Field.newField().name("dummy").build()))
                 .build()
 
         when:
@@ -942,8 +942,8 @@ class ExecutionStrategyTest extends Specification {
                 .executionStepInfo(executionStepInfo)
                 .source(result)
                 .nonNullFieldValidator(nullableFieldValidator)
-                .fields(mergedSelectionSet(["fld": [mergedField(Field.newField().build())]]))
-                .field(mergedField(Field.newField().build()))
+                .fields(mergedSelectionSet(["fld": [mergedField(Field.newField().name("dummy").build())]]))
+                .field(mergedField(Field.newField().name("dummy").build()))
                 .build()
 
         when:
@@ -966,8 +966,8 @@ class ExecutionStrategyTest extends Specification {
                 .executionStepInfo(typeInfo)
                 .source(result)
                 .nonNullFieldValidator(nullableFieldValidator)
-                .fields(mergedSelectionSet(["fld": [mergedField(Field.newField().build())]]))
-                .field(mergedField(Field.newField().build()))
+                .fields(mergedSelectionSet(["fld": [mergedField(Field.newField().name("dummy").build())]]))
+                .field(mergedField(Field.newField().name("dummy").build()))
                 .build()
 
         when:
diff --git a/src/test/groovy/graphql/execution/directives/OperationDirectivesResolverTest.groovy b/src/test/groovy/graphql/execution/directives/OperationDirectivesResolverTest.groovy
new file mode 100644
index 0000000000..9f5de2632c
--- /dev/null
+++ b/src/test/groovy/graphql/execution/directives/OperationDirectivesResolverTest.groovy
@@ -0,0 +1,203 @@
+package graphql.execution.directives
+
+import com.google.common.collect.ImmutableList
+import graphql.ExecutionInput
+import graphql.ExecutionResult
+import graphql.GraphQL
+import graphql.GraphQLContext
+import graphql.TestUtil
+import graphql.execution.CoercedVariables
+import graphql.execution.ExecutionContext
+import graphql.execution.instrumentation.Instrumentation
+import graphql.execution.instrumentation.InstrumentationContext
+import graphql.execution.instrumentation.InstrumentationState
+import graphql.execution.instrumentation.parameters.InstrumentationExecuteOperationParameters
+import graphql.language.Document
+import graphql.language.OperationDefinition
+import graphql.schema.GraphQLScalarType
+import graphql.util.FpKit
+import spock.lang.Specification
+
+class OperationDirectivesResolverTest extends Specification {
+
+    def schema = TestUtil.schema("""
+            directive @foo on QUERY | MUTATION | SUBSCRIPTION
+            directive @bar on QUERY | MUTATION | SUBSCRIPTION
+            directive @baz repeatable on QUERY | MUTATION | SUBSCRIPTION
+            directive @timeout(ms : Int = -1) on QUERY | MUTATION | SUBSCRIPTION
+
+            type Query {
+                f : String
+            } 
+            type Mutation {
+                f : String
+            } 
+            type Subscription {
+                f : String
+            } 
+        """)
+
+    def "can resolve out directives on a document"() {
+
+
+        def document = TestUtil.parseQuery("""
+            query q1 @foo {
+                f
+            }
+
+            query q2 @bar {
+                f
+            }
+
+            mutation m1 @baz @baz {
+                f
+            }
+            
+            subscription s1 @timeout(ms : 100) {
+                f
+            }            
+           
+        """)
+
+        when:
+        def resolveDirectives = new OperationDirectivesResolver()
+                .resolveDirectives(document, schema, CoercedVariables.emptyVariables(), GraphQLContext.getDefault(), Locale.getDefault())
+
+        def data = resolveDirectives.collectEntries { operation, directives ->
+            [operation.name, directives.collect { it.name }] // remap to names
+        }
+        then:
+        !resolveDirectives.isEmpty()
+        data["q1"] == ["foo"]
+        data["q2"] == ["bar"]
+        data["m1"] == ["baz", "baz"]
+        data["s1"] == ["timeout"]
+    }
+
+    def "can resolve out directives on an operation"() {
+
+        def document = TestUtil.parseQuery("""
+            query q1 @timeout(ms : 100) @foo @bar {
+                f
+            }
+        """)
+
+        def operationDefinition = extractOp(document)
+
+        when:
+        def resolveDirectives = new OperationDirectivesResolver()
+                .resolveDirectivesByName(operationDefinition, schema, CoercedVariables.emptyVariables(), GraphQLContext.getDefault(), Locale.getDefault())
+
+        then:
+        resolveDirectives.size() == 3
+        def directives = resolveDirectives["timeout"]
+        directives.size() == 1
+
+        timeoutAsserts(directives[0], 100)
+    }
+
+    def "can default values in directives"() {
+        def document = TestUtil.parseQuery("""
+            query q1 @timeout @foo @bar {
+                f
+            }
+        """)
+        def operationDefinition = extractOp(document)
+
+        when:
+        def resolveDirectives = new OperationDirectivesResolver()
+                .resolveDirectivesByName(operationDefinition, schema, CoercedVariables.emptyVariables(), GraphQLContext.getDefault(), Locale.getDefault())
+
+        then:
+        resolveDirectives.size() == 3
+        def directives = resolveDirectives["timeout"]
+        directives.size() == 1
+
+        timeoutAsserts(directives[0], -1)
+
+    }
+
+
+    private static boolean timeoutAsserts(QueryAppliedDirective directive, Integer value) {
+        assert directive.name == "timeout"
+        assert directive.arguments.size() == 1
+        assert directive.arguments[0].name == "ms"
+        assert (directive.arguments[0].type as GraphQLScalarType).name == "Int"
+        assert directive.arguments[0].value == value
+        true
+    }
+
+    def "integration test"() {
+
+        ExecutionContext executionContext = null
+        Instrumentation instrumentation = new Instrumentation() {
+            @Override
+            InstrumentationContext<ExecutionResult> beginExecuteOperation(InstrumentationExecuteOperationParameters parameters, InstrumentationState state) {
+                executionContext = parameters.getExecutionContext()
+                return null
+            }
+        }
+
+        def graphQL = GraphQL.newGraphQL(schema).instrumentation(instrumentation).build()
+
+        when:
+        def ei = ExecutionInput.newExecutionInput("""
+            query q1 @timeout(ms : 100) @foo @bar @baz @baz {
+                f
+            }
+            
+            mutation m1 @timeout(ms : 100) @foo @bar @baz @baz {
+                f
+            }
+        """).operationName("q1").build()
+        graphQL.execute(ei)
+
+
+        then:
+        def resolveDirectives = executionContext.getOperationDirectives()
+
+        commonIntegrationAsserts(resolveDirectives)
+
+        when:
+        def normalizedOperation = executionContext.getNormalizedQueryTree().get()
+        def enoResolveDirectives = normalizedOperation.getOperationDirectives()
+
+        then:
+        commonIntegrationAsserts(enoResolveDirectives)
+
+        when:
+        def allOperationDirectives = executionContext.getAllOperationDirectives()
+
+        then:
+        allOperationDirectives.size() == 2
+        ImmutableList<QueryAppliedDirective> firstList = allOperationDirectives.values().iterator().next()
+        def firstResolvedDirectives = FpKit.groupingBy(firstList, { it -> it.name })
+        commonIntegrationAsserts(firstResolvedDirectives)
+
+    }
+
+    private static boolean commonIntegrationAsserts(Map<String, ImmutableList<QueryAppliedDirective>> resolveDirectives) {
+        assert resolveDirectives.size() == 4
+        def directives = resolveDirectives["timeout"]
+        assert directives.size() == 1
+
+        def directive = directives[0]
+        assert directive.name == "timeout"
+        assert directive.arguments.size() == 1
+        assert directive.arguments[0].name == "ms"
+        assert (directive.arguments[0].type as GraphQLScalarType).name == "Int"
+        assert directive.arguments[0].value == 100
+
+        assert  resolveDirectives["foo"].size() == 1
+        assert  resolveDirectives["bar"].size() == 1
+        assert  resolveDirectives["baz"].size() == 2
+
+        true
+
+    }
+
+    private static OperationDefinition extractOp(Document document) {
+        document.getDefinitionsOfType(OperationDefinition.class)[0]
+    }
+
+}
diff --git a/src/test/groovy/graphql/execution/instrumentation/dataloader/BatchCompareDataFetchers.java b/src/test/groovy/graphql/execution/instrumentation/dataloader/BatchCompareDataFetchers.java
index 08edd13248..36829b0130 100644
--- a/src/test/groovy/graphql/execution/instrumentation/dataloader/BatchCompareDataFetchers.java
+++ b/src/test/groovy/graphql/execution/instrumentation/dataloader/BatchCompareDataFetchers.java
@@ -16,6 +16,9 @@
 import java.util.Optional;
 import java.util.Random;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.function.Supplier;
@@ -32,10 +35,21 @@ public class BatchCompareDataFetchers {
 
     AtomicBoolean useAsyncBatchLoading = new AtomicBoolean(false);
 
+    private volatile CountDownLatch rootFetcherRendezvous;
+    private volatile CountDownLatch completionOverlapLatch;
+    private final AtomicBoolean shopsOverlapSignaled = new AtomicBoolean(false);
+    private final AtomicBoolean exShopsOverlapSignaled = new AtomicBoolean(false);
+    private final ExecutorService executor = Executors.newFixedThreadPool(4);
+
     public void useAsyncBatchLoading(boolean flag) {
         useAsyncBatchLoading.set(flag);
     }
 
+    public void useSynchronizedFetching(int numberOfRootFetchers) {
+        rootFetcherRendezvous = new CountDownLatch(numberOfRootFetchers);
+        completionOverlapLatch = new CountDownLatch(numberOfRootFetchers);
+    }
+
 
     private static final Map<String, Shop> shops = new LinkedHashMap<>();
     private static final Map<String, Shop> expensiveShops = new LinkedHashMap<>();
@@ -52,10 +66,10 @@ public void useAsyncBatchLoading(boolean flag) {
 
 
     public DataFetcher<CompletableFuture<List<Shop>>> shopsDataFetcher =
-            environment -> supplyAsyncWithSleep(() -> new ArrayList<>(shops.values()));
+            environment -> supplyAsyncWithRendezvous(() -> new ArrayList<>(shops.values()));
 
     public DataFetcher<CompletableFuture<List<Shop>>> expensiveShopsDataFetcher = environment ->
-            supplyAsyncWithSleep(() -> new ArrayList<>(expensiveShops.values()));
+            supplyAsyncWithRendezvous(() -> new ArrayList<>(expensiveShops.values()));
 
     // Departments
     private static Map<String, Department> departments = new LinkedHashMap<>();
@@ -101,6 +115,21 @@ private static List<List<Department>> getDepartmentsForShops(List<Shop> shops) {
 
     public DataFetcher<CompletableFuture<List<Department>>> departmentsForShopDataLoaderDataFetcher = environment -> {
         Shop shop = environment.getSource();
+        // When synchronized fetching is enabled, ensure both root fields (shops and expensiveShops)
+        // are inside their startComplete/stopComplete window before either proceeds.
+        // This guarantees objectRunningCount never drops to 0 prematurely.
+        CountDownLatch overlapLatch = completionOverlapLatch;
+        if (overlapLatch != null) {
+            AtomicBoolean flag = shop.getId().startsWith("ex") ? exShopsOverlapSignaled : shopsOverlapSignaled;
+            if (flag.compareAndSet(false, true)) {
+                overlapLatch.countDown();
+                try {
+                    overlapLatch.await();
+                } catch (InterruptedException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
         return (CompletableFuture) environment.getDataLoader("departments").load(shop.getId());
     };
 
@@ -149,6 +178,22 @@ private <T> CompletableFuture<T> maybeAsyncWithSleep(Supplier<CompletableFuture<
         }
     }
 
+    private <T> CompletableFuture<T> supplyAsyncWithRendezvous(Supplier<T> supplier) {
+        CountDownLatch latch = rootFetcherRendezvous;
+        if (latch != null) {
+            return CompletableFuture.supplyAsync(() -> {
+                try {
+                    latch.countDown();
+                    latch.await();
+                } catch (InterruptedException e) {
+                    throw new RuntimeException(e);
+                }
+                return supplier.get();
+            }, executor);
+        }
+        return supplyAsyncWithSleep(supplier);
+    }
+
     private static <T> CompletableFuture<T> supplyAsyncWithSleep(Supplier<T> supplier) {
         Supplier<T> sleepSome = sleepSome(supplier);
         return CompletableFuture.supplyAsync(sleepSome);
diff --git a/src/test/groovy/graphql/execution/instrumentation/dataloader/DataLoaderPerformanceTest.groovy b/src/test/groovy/graphql/execution/instrumentation/dataloader/DataLoaderPerformanceTest.groovy
index 1ee790ded3..6a1a2e09d9 100644
--- a/src/test/groovy/graphql/execution/instrumentation/dataloader/DataLoaderPerformanceTest.groovy
+++ b/src/test/groovy/graphql/execution/instrumentation/dataloader/DataLoaderPerformanceTest.groovy
@@ -60,6 +60,8 @@ class DataLoaderPerformanceTest extends Specification {
 
         when:
 
+        batchCompareDataFetchers.useSynchronizedFetching(2)
+
         ExecutionInput executionInput = ExecutionInput.newExecutionInput()
                 .query(getExpensiveQuery(false))
                 .dataLoaderRegistry(dataLoaderRegistry)
@@ -71,8 +73,8 @@ class DataLoaderPerformanceTest extends Specification {
         then:
         result.data == expectedExpensiveData
 
-        batchCompareDataFetchers.departmentsForShopsBatchLoaderCounter.get() <= 2
-        batchCompareDataFetchers.productsForDepartmentsBatchLoaderCounter.get() <= 2
+        batchCompareDataFetchers.departmentsForShopsBatchLoaderCounter.get() == 1
+        batchCompareDataFetchers.productsForDepartmentsBatchLoaderCounter.get() == 1
 
         where:
         incrementalSupport | contextKey
@@ -123,6 +125,7 @@ class DataLoaderPerformanceTest extends Specification {
         when:
 
         batchCompareDataFetchers.useAsyncBatchLoading(true)
+        batchCompareDataFetchers.useSynchronizedFetching(2)
 
         ExecutionInput executionInput = ExecutionInput.newExecutionInput()
                 .query(getExpensiveQuery(false))
@@ -136,8 +139,8 @@ class DataLoaderPerformanceTest extends Specification {
         then:
         result.data == expectedExpensiveData
 
-        batchCompareDataFetchers.departmentsForShopsBatchLoaderCounter.get() <= 2
-        batchCompareDataFetchers.productsForDepartmentsBatchLoaderCounter.get() <= 2
+        batchCompareDataFetchers.departmentsForShopsBatchLoaderCounter.get() == 1
+        batchCompareDataFetchers.productsForDepartmentsBatchLoaderCounter.get() == 1
 
         where:
         incrementalSupport | contextKey
diff --git a/src/test/groovy/graphql/execution/instrumentation/dataloader/DataLoaderPerformanceWithChainedInstrumentationTest.groovy b/src/test/groovy/graphql/execution/instrumentation/dataloader/DataLoaderPerformanceWithChainedInstrumentationTest.groovy
index 5467c87220..9e779765fd 100644
--- a/src/test/groovy/graphql/execution/instrumentation/dataloader/DataLoaderPerformanceWithChainedInstrumentationTest.groovy
+++ b/src/test/groovy/graphql/execution/instrumentation/dataloader/DataLoaderPerformanceWithChainedInstrumentationTest.groovy
@@ -3,7 +3,6 @@ package graphql.execution.instrumentation.dataloader
 import graphql.ExecutionInput
 import graphql.GraphQL
 import org.dataloader.DataLoaderRegistry
-import spock.lang.Ignore
 import spock.lang.Specification
 
 import static graphql.ExperimentalApi.ENABLE_INCREMENTAL_SUPPORT
@@ -49,11 +48,12 @@ class DataLoaderPerformanceWithChainedInstrumentationTest extends Specification
         incrementalSupport << [true, false]
     }
 
-    @Ignore("This test flakes on Travis for some reason.  Clearly this indicates some sort of problem to investigate.  However it also stop releases.")
     def "chainedInstrumentation: 970 ensure data loader is performant for multiple field with lists"() {
 
         when:
 
+        batchCompareDataFetchers.useSynchronizedFetching(2)
+
         ExecutionInput executionInput = ExecutionInput.newExecutionInput()
                 .query(getExpensiveQuery(false))
                 .dataLoaderRegistry(dataLoaderRegistry)
@@ -101,6 +101,7 @@ class DataLoaderPerformanceWithChainedInstrumentationTest extends Specification
         when:
 
         batchCompareDataFetchers.useAsyncBatchLoading(true)
+        batchCompareDataFetchers.useSynchronizedFetching(2)
 
         ExecutionInput executionInput = ExecutionInput.newExecutionInput()
                 .query(getExpensiveQuery(false))
@@ -112,8 +113,8 @@ class DataLoaderPerformanceWithChainedInstrumentationTest extends Specification
         then:
         result.data == expectedExpensiveData
 
-        batchCompareDataFetchers.departmentsForShopsBatchLoaderCounter.get() <= 2
-        batchCompareDataFetchers.productsForDepartmentsBatchLoaderCounter.get() <= 2
+        batchCompareDataFetchers.departmentsForShopsBatchLoaderCounter.get() == 1
+        batchCompareDataFetchers.productsForDepartmentsBatchLoaderCounter.get() == 1
 
         where:
         incrementalSupport << [true, false]
diff --git a/src/test/groovy/graphql/execution/instrumentation/dataloader/DeferWithDataLoaderTest.groovy b/src/test/groovy/graphql/execution/instrumentation/dataloader/DeferWithDataLoaderTest.groovy
index 0fe86e3fba..2f87b53283 100644
--- a/src/test/groovy/graphql/execution/instrumentation/dataloader/DeferWithDataLoaderTest.groovy
+++ b/src/test/groovy/graphql/execution/instrumentation/dataloader/DeferWithDataLoaderTest.groovy
@@ -388,6 +388,183 @@ class DeferWithDataLoaderTest extends Specification {
 
     }
 
+    @Unroll
+    def "multiple separate defer fragments with dataloader fields dispatch correctly"() {
+        given:
+        def query = """
+            query {
+                shops {
+                    id
+                    name
+                    ... @defer(label: "deferred1") {
+                        departments {
+                            name
+                        }
+                    }
+                    ... @defer(label: "deferred2") {
+                        expensiveDepartments {
+                            name
+                        }
+                    }
+                }
+            }
+        """
+
+        def expectedInitialData = [
+                data   : [
+                        shops: [
+                                [id: "shop-1", name: "Shop 1"],
+                                [id: "shop-2", name: "Shop 2"],
+                                [id: "shop-3", name: "Shop 3"],
+                        ]
+                ],
+                hasNext: true
+        ]
+
+        when:
+        ExecutionInput executionInput = ExecutionInput.newExecutionInput()
+                .query(query)
+                .dataLoaderRegistry(dataLoaderRegistry)
+                .graphQLContext([(ENABLE_INCREMENTAL_SUPPORT): true])
+                .build()
+        executionInput.getGraphQLContext().putAll(contextKey == null ? Collections.emptyMap() : [(contextKey): true])
+
+        IncrementalExecutionResult result = graphQL.execute(executionInput)
+
+        then:
+        result.toSpecification() == expectedInitialData
+
+        when:
+        def incrementalResults = getIncrementalResults(result)
+
+        then:
+        assertIncrementalResults(incrementalResults, [["shops", 0], ["shops", 1], ["shops", 2], ["shops", 0], ["shops", 1], ["shops", 2]])
+
+        when:
+        def combined = combineExecutionResults(result.toSpecification(), incrementalResults)
+        then:
+        combined.errors == null
+        combined.data == [
+                shops: [
+                        [id                  : "shop-1", name: "Shop 1",
+                         departments         : [[name: "Department 1"],
+                                                [name: "Department 2"],
+                                                [name: "Department 3"]],
+                         expensiveDepartments: [[name: "Department 1"],
+                                                [name: "Department 2"],
+                                                [name: "Department 3"]]],
+                        [id                  : "shop-2", name: "Shop 2",
+                         departments         : [[name: "Department 4"],
+                                                [name: "Department 5"],
+                                                [name: "Department 6"]],
+                         expensiveDepartments: [[name: "Department 4"],
+                                                [name: "Department 5"],
+                                                [name: "Department 6"]]],
+                        [id                  : "shop-3", name: "Shop 3",
+                         departments         : [[name: "Department 7"],
+                                                [name: "Department 8"],
+                                                [name: "Department 9"]],
+                         expensiveDepartments: [[name: "Department 7"],
+                                                [name: "Department 8"],
+                                                [name: "Department 9"]]]]
+        ]
+
+        where:
+        contextKey << [ENABLE_DATA_LOADER_CHAINING, ENABLE_DATA_LOADER_EXHAUSTED_DISPATCHING, null]
+    }
+
+    @Unroll
+    def "mixed deferred and non-deferred fields with dataloaders dispatch correctly"() {
+        given:
+        def query = """
+            query {
+                shops {
+                    id
+                    name
+                    departments {
+                        name
+                    }
+                    ... @defer(label: "deferred1") {
+                        expensiveDepartments {
+                            name
+                        }
+                    }
+                }
+            }
+        """
+
+        def expectedInitialData = [
+                data   : [
+                        shops: [
+                                [id: "shop-1", name: "Shop 1",
+                                 departments: [[name: "Department 1"],
+                                               [name: "Department 2"],
+                                               [name: "Department 3"]]],
+                                [id: "shop-2", name: "Shop 2",
+                                 departments: [[name: "Department 4"],
+                                               [name: "Department 5"],
+                                               [name: "Department 6"]]],
+                                [id: "shop-3", name: "Shop 3",
+                                 departments: [[name: "Department 7"],
+                                               [name: "Department 8"],
+                                               [name: "Department 9"]]],
+                        ]
+                ],
+                hasNext: true
+        ]
+
+        when:
+        ExecutionInput executionInput = ExecutionInput.newExecutionInput()
+                .query(query)
+                .dataLoaderRegistry(dataLoaderRegistry)
+                .graphQLContext([(ENABLE_INCREMENTAL_SUPPORT): true])
+                .build()
+        executionInput.getGraphQLContext().putAll(contextKey == null ? Collections.emptyMap() : [(contextKey): true])
+
+        IncrementalExecutionResult result = graphQL.execute(executionInput)
+
+        then:
+        result.toSpecification() == expectedInitialData
+
+        when:
+        def incrementalResults = getIncrementalResults(result)
+
+        then:
+        assertIncrementalResults(incrementalResults, [["shops", 0], ["shops", 1], ["shops", 2]])
+
+        when:
+        def combined = combineExecutionResults(result.toSpecification(), incrementalResults)
+        then:
+        combined.errors == null
+        combined.data == [
+                shops: [
+                        [id                  : "shop-1", name: "Shop 1",
+                         departments         : [[name: "Department 1"],
+                                                [name: "Department 2"],
+                                                [name: "Department 3"]],
+                         expensiveDepartments: [[name: "Department 1"],
+                                                [name: "Department 2"],
+                                                [name: "Department 3"]]],
+                        [id                  : "shop-2", name: "Shop 2",
+                         departments         : [[name: "Department 4"],
+                                                [name: "Department 5"],
+                                                [name: "Department 6"]],
+                         expensiveDepartments: [[name: "Department 4"],
+                                                [name: "Department 5"],
+                                                [name: "Department 6"]]],
+                        [id                  : "shop-3", name: "Shop 3",
+                         departments         : [[name: "Department 7"],
+                                                [name: "Department 8"],
+                                                [name: "Department 9"]],
+                         expensiveDepartments: [[name: "Department 7"],
+                                                [name: "Department 8"],
+                                                [name: "Department 9"]]]]
+        ]
+
+        where:
+        contextKey << [ENABLE_DATA_LOADER_CHAINING, ENABLE_DATA_LOADER_EXHAUSTED_DISPATCHING, null]
+    }
+
     @Unroll
     @RepeatUntilFailure(maxAttempts = 20, ignoreRest = false)
     def "dataloader in initial result and chained dataloader inside nested defer block"() {
diff --git a/src/test/groovy/graphql/execution/instrumentation/dataloader/ExhaustedDataLoaderDispatchStrategyTest.groovy b/src/test/groovy/graphql/execution/instrumentation/dataloader/ExhaustedDataLoaderDispatchStrategyTest.groovy
new file mode 100644
index 0000000000..dd61b39071
--- /dev/null
+++ b/src/test/groovy/graphql/execution/instrumentation/dataloader/ExhaustedDataLoaderDispatchStrategyTest.groovy
@@ -0,0 +1,433 @@
+package graphql.execution.instrumentation.dataloader
+
+import graphql.ExecutionInput
+import graphql.EngineRunningState
+import graphql.GraphQLContext
+import graphql.Profiler
+import graphql.execution.AsyncExecutionStrategy
+import graphql.execution.CoercedVariables
+import graphql.execution.ExecutionContext
+import graphql.execution.ExecutionContextBuilder
+import graphql.execution.ExecutionId
+import graphql.execution.ExecutionStepInfo
+import graphql.execution.ExecutionStrategyParameters
+import graphql.execution.NonNullableFieldValidator
+import graphql.execution.ResultPath
+import graphql.execution.incremental.AlternativeCallContext
+import graphql.schema.GraphQLSchema
+import org.dataloader.BatchLoader
+import org.dataloader.DataLoaderFactory
+import org.dataloader.DataLoaderRegistry
+import spock.lang.Specification
+
+import java.util.concurrent.CompletableFuture
+import java.util.concurrent.CompletionStage
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.TimeUnit
+import java.util.concurrent.atomic.AtomicInteger
+
+import static graphql.Scalars.GraphQLString
+import static graphql.execution.ExecutionStepInfo.newExecutionStepInfo
+import static graphql.execution.ExecutionStrategyParameters.newParameters
+
+class ExhaustedDataLoaderDispatchStrategyTest extends Specification {
+
+    AtomicInteger batchLoaderInvocations
+    DataLoaderRegistry dataLoaderRegistry
+    ExecutionContext executionContext
+    ExhaustedDataLoaderDispatchStrategy strategy
+
+    ExecutionStrategyParameters rootParams
+
+    def setup() {
+        batchLoaderInvocations = new AtomicInteger()
+    }
+
+    private void setupStrategy(BatchLoader<String, String> batchLoader) {
+        dataLoaderRegistry = new DataLoaderRegistry()
+        def dataLoader = DataLoaderFactory.newDataLoader(batchLoader)
+        dataLoaderRegistry.register("testLoader", dataLoader)
+
+        def executionInput = ExecutionInput.newExecutionInput()
+                .query("{ dummy }")
+                .build()
+        def engineRunningState = new EngineRunningState(executionInput, Profiler.NO_OP)
+
+        def executionStrategy = new AsyncExecutionStrategy()
+        executionContext = new ExecutionContextBuilder()
+                .executionId(ExecutionId.generate())
+                .graphQLSchema(GraphQLSchema.newSchema().query(
+                        graphql.schema.GraphQLObjectType.newObject()
+                                .name("Query")
+                                .field({ f -> f.name("dummy").type(GraphQLString) })
+                                .build()
+                ).build())
+                .queryStrategy(executionStrategy)
+                .mutationStrategy(executionStrategy)
+                .subscriptionStrategy(executionStrategy)
+                .graphQLContext(GraphQLContext.newContext().build())
+                .coercedVariables(CoercedVariables.emptyVariables())
+                .dataLoaderRegistry(dataLoaderRegistry)
+                .executionInput(executionInput)
+                .profiler(Profiler.NO_OP)
+                .engineRunningState(engineRunningState)
+                .build()
+
+        strategy = new ExhaustedDataLoaderDispatchStrategy(executionContext)
+
+        rootParams = newParameters()
+                .executionStepInfo(newExecutionStepInfo()
+                        .type(GraphQLString)
+                        .path(ResultPath.rootPath())
+                        .build())
+                .source(new Object())
+                .fields(graphql.execution.MergedSelectionSet.newMergedSelectionSet().build())
+                .nonNullFieldValidator(new NonNullableFieldValidator(executionContext))
+                .build()
+    }
+
+    private BatchLoader<String, String> simpleBatchLoader() {
+        return new BatchLoader<String, String>() {
+            @Override
+            CompletionStage<List<String>> load(List<String> keys) {
+                batchLoaderInvocations.incrementAndGet()
+                return CompletableFuture.completedFuture(keys)
+            }
+        }
+    }
+
+    def "basic dispatch cycle - finishedFetching triggers dispatch when objectRunning reaches 0"() {
+        given:
+        setupStrategy(simpleBatchLoader())
+        // Load a key so the data loader has pending work
+        dataLoaderRegistry.getDataLoader("testLoader").load("key1")
+
+        when:
+        // executionStrategy: increments running count to 1
+        strategy.executionStrategy(executionContext, rootParams, 1)
+        // newDataLoaderInvocation: sets dataLoaderToDispatch = true; running > 0 so no dispatch yet
+        strategy.newDataLoaderInvocation(null)
+        // finishedFetching: decrements running to 0; all conditions met -> dispatch fires
+        strategy.finishedFetching(executionContext, rootParams)
+
+        // Give async dispatch a moment to complete
+        Thread.sleep(100)
+
+        then:
+        batchLoaderInvocations.get() == 1
+    }
+
+    def "early return in newDataLoaderInvocation when dataLoaderToDispatch already set"() {
+        given:
+        setupStrategy(simpleBatchLoader())
+        dataLoaderRegistry.getDataLoader("testLoader").load("key1")
+
+        when:
+        strategy.executionStrategy(executionContext, rootParams, 1)
+        // First call sets dataLoaderToDispatch = true
+        strategy.newDataLoaderInvocation(null)
+        // Second call: flag already true -> early return at line 223
+        strategy.newDataLoaderInvocation(null)
+        // Dispatch via finishedFetching
+        strategy.finishedFetching(executionContext, rootParams)
+
+        Thread.sleep(100)
+
+        then:
+        // Batch loader should be called exactly once despite two newDataLoaderInvocation calls
+        batchLoaderInvocations.get() == 1
+    }
+
+    def "dispatch triggered from newDataLoaderInvocation when objectRunningCount is already 0"() {
+        given:
+        setupStrategy(simpleBatchLoader())
+
+        when:
+        // executionStrategy: running count = 1
+        strategy.executionStrategy(executionContext, rootParams, 1)
+        // finishedFetching: running count = 0, but dataLoaderToDispatch is false -> no dispatch
+        strategy.finishedFetching(executionContext, rootParams)
+
+        // Now load a key so there's pending work
+        dataLoaderRegistry.getDataLoader("testLoader").load("key1")
+
+        // newDataLoaderInvocation: sets dataLoaderToDispatch = true; running == 0 -> dispatches from line 233
+        strategy.newDataLoaderInvocation(null)
+
+        Thread.sleep(100)
+
+        then:
+        batchLoaderInvocations.get() == 1
+    }
+
+    def "multiple dispatch rounds when data loader invocation happens during dispatch"() {
+        given:
+        def secondRoundLatch = new CountDownLatch(1)
+        AtomicInteger roundCount = new AtomicInteger()
+
+        // A batch loader that on the first call, loads another key (triggering a second dispatch round)
+        def chainedBatchLoader = new BatchLoader<String, String>() {
+            @Override
+            CompletionStage<List<String>> load(List<String> keys) {
+                int round = roundCount.incrementAndGet()
+                if (round == 1) {
+                    // During first batch, load another key to trigger second dispatch
+                    dataLoaderRegistry.getDataLoader("testLoader").load("key2")
+                    strategy.newDataLoaderInvocation(null)
+                }
+                if (round == 2) {
+                    secondRoundLatch.countDown()
+                }
+                return CompletableFuture.completedFuture(keys)
+            }
+        }
+        setupStrategy(chainedBatchLoader)
+
+        dataLoaderRegistry.getDataLoader("testLoader").load("key1")
+
+        when:
+        strategy.executionStrategy(executionContext, rootParams, 1)
+        strategy.newDataLoaderInvocation(null)
+        strategy.finishedFetching(executionContext, rootParams)
+
+        // Wait for second dispatch round
+        def completed = secondRoundLatch.await(2, TimeUnit.SECONDS)
+
+        then:
+        completed
+        roundCount.get() == 2
+    }
+
+    def "executionSerialStrategy clears and re-initializes state"() {
+        given:
+        setupStrategy(simpleBatchLoader())
+        dataLoaderRegistry.getDataLoader("testLoader").load("key1")
+
+        when:
+        // Start with a root execution
+        strategy.executionStrategy(executionContext, rootParams, 1)
+        // executionSerialStrategy clears state and re-inits running count
+        strategy.executionSerialStrategy(executionContext, rootParams)
+        // Set dataLoaderToDispatch
+        strategy.newDataLoaderInvocation(null)
+        // Finish fetching -> should dispatch
+        strategy.finishedFetching(executionContext, rootParams)
+
+        Thread.sleep(100)
+
+        then:
+        batchLoaderInvocations.get() == 1
+    }
+
+    def "alternative call context - subscription creates separate call stack"() {
+        given:
+        setupStrategy(simpleBatchLoader())
+        dataLoaderRegistry.getDataLoader("testLoader").load("key1")
+        def altCtx = new AlternativeCallContext()
+
+        when:
+        // Also start the initial call stack so it doesn't interfere
+        strategy.executionStrategy(executionContext, rootParams, 1)
+
+        // Create subscription call stack
+        strategy.newSubscriptionExecution(altCtx)
+        // Signal data loader invocation on subscription context
+        strategy.newDataLoaderInvocation(altCtx)
+        // Complete subscription event -> triggers dispatch on subscription call stack
+        strategy.subscriptionEventCompletionDone(altCtx)
+
+        Thread.sleep(100)
+
+        then:
+        batchLoaderInvocations.get() == 1
+    }
+
+    def "startComplete and stopComplete affect dispatch"() {
+        given:
+        setupStrategy(simpleBatchLoader())
+        dataLoaderRegistry.getDataLoader("testLoader").load("key1")
+
+        when:
+        strategy.executionStrategy(executionContext, rootParams, 1)
+        // startComplete increments running count
+        strategy.startComplete(rootParams)
+        // finishedFetching decrements, but running count is still > 0 due to startComplete
+        strategy.finishedFetching(executionContext, rootParams)
+        // Set dataLoaderToDispatch
+        strategy.newDataLoaderInvocation(null)
+        // stopComplete decrements to 0 -> triggers dispatch
+        strategy.stopComplete(rootParams)
+
+        Thread.sleep(100)
+
+        then:
+        batchLoaderInvocations.get() == 1
+    }
+
+    def "deferred call context creates lazy call stack via computeIfAbsent"() {
+        given:
+        setupStrategy(simpleBatchLoader())
+        dataLoaderRegistry.getDataLoader("testLoader").load("key1")
+
+        // Create params with a deferred call context
+        def deferCtx = new AlternativeCallContext(1, 1)
+        def deferredParams = newParameters()
+                .executionStepInfo(newExecutionStepInfo()
+                        .type(GraphQLString)
+                        .path(ResultPath.rootPath())
+                        .build())
+                .source(new Object())
+                .fields(graphql.execution.MergedSelectionSet.newMergedSelectionSet().build())
+                .nonNullFieldValidator(new NonNullableFieldValidator(executionContext))
+                .deferredCallContext(deferCtx)
+                .build()
+
+        when:
+        // Start initial execution
+        strategy.executionStrategy(executionContext, rootParams, 1)
+
+        // finishedFetching with deferred params triggers lazy call stack creation
+        // The computeIfAbsent in getCallStack creates a new CallStack and increments its running count
+        // Then finishedFetching decrements it -> running count = 0
+        strategy.newDataLoaderInvocation(deferCtx)
+        strategy.finishedFetching(executionContext, deferredParams)
+
+        Thread.sleep(100)
+
+        then:
+        // The deferred call stack dispatches independently
+        batchLoaderInvocations.get() == 1
+    }
+
+    /**
+     * A CallStack subclass that forces CAS failures to deterministically exercise
+     * the retry paths in dispatchImpl's CAS loop. Without this, CAS retries only
+     * happen under real thread contention, making coverage non-deterministic.
+     *
+     * Failures are targeted: only CAS attempts matching a specific state transition
+     * (identified by the newState pattern) are failed, so other CAS users like
+     * incrementObjectRunningCount/decrementObjectRunningCount are not affected.
+     */
+    static class ContendedCallStack extends ExhaustedDataLoaderDispatchStrategy.CallStack {
+        // The newState value that should trigger a simulated CAS failure
+        volatile int failOnNewState = -1
+        final AtomicInteger casFailuresRemaining = new AtomicInteger(0)
+
+        @Override
+        boolean tryUpdateState(int oldState, int newState) {
+            if (newState == failOnNewState && casFailuresRemaining.getAndDecrement() > 0) {
+                return false
+            }
+            return super.tryUpdateState(oldState, newState)
+        }
+    }
+
+    private void setupStrategyWithCallStack(BatchLoader<String, String> batchLoader, ExhaustedDataLoaderDispatchStrategy.CallStack callStack) {
+        dataLoaderRegistry = new DataLoaderRegistry()
+        def dataLoader = DataLoaderFactory.newDataLoader(batchLoader)
+        dataLoaderRegistry.register("testLoader", dataLoader)
+
+        def executionInput = ExecutionInput.newExecutionInput()
+                .query("{ dummy }")
+                .build()
+        def engineRunningState = new EngineRunningState(executionInput, Profiler.NO_OP)
+
+        def executionStrategy = new AsyncExecutionStrategy()
+        executionContext = new ExecutionContextBuilder()
+                .executionId(ExecutionId.generate())
+                .graphQLSchema(GraphQLSchema.newSchema().query(
+                        graphql.schema.GraphQLObjectType.newObject()
+                                .name("Query")
+                                .field({ f -> f.name("dummy").type(GraphQLString) })
+                                .build()
+                ).build())
+                .queryStrategy(executionStrategy)
+                .mutationStrategy(executionStrategy)
+                .subscriptionStrategy(executionStrategy)
+                .graphQLContext(GraphQLContext.newContext().build())
+                .coercedVariables(CoercedVariables.emptyVariables())
+                .dataLoaderRegistry(dataLoaderRegistry)
+                .executionInput(executionInput)
+                .profiler(Profiler.NO_OP)
+                .engineRunningState(engineRunningState)
+                .build()
+
+        strategy = new ExhaustedDataLoaderDispatchStrategy(executionContext, callStack)
+
+        rootParams = newParameters()
+                .executionStepInfo(newExecutionStepInfo()
+                        .type(GraphQLString)
+                        .path(ResultPath.rootPath())
+                        .build())
+                .source(new Object())
+                .fields(graphql.execution.MergedSelectionSet.newMergedSelectionSet().build())
+                .nonNullFieldValidator(new NonNullableFieldValidator(executionContext))
+                .build()
+    }
+
+    def "CAS retry in dispatchImpl dispatch path is exercised under contention"() {
+        given:
+        def contendedCallStack = new ContendedCallStack()
+        setupStrategyWithCallStack(simpleBatchLoader(), contendedCallStack)
+        dataLoaderRegistry.getDataLoader("testLoader").load("key1")
+
+        when:
+        strategy.executionStrategy(executionContext, rootParams, 1)
+        strategy.newDataLoaderInvocation(null)
+        // The dispatch-setup CAS in dispatchImpl sets currentlyDispatching=true and
+        // dataLoaderToDispatch=false. With objectRunningCount=0, the target newState is:
+        // currentlyDispatching(bit0)=1, dataLoaderToDispatch(bit1)=0, objectRunningCount(bits2+)=0
+        // = 0b01 = 1
+        contendedCallStack.failOnNewState = ExhaustedDataLoaderDispatchStrategy.CallStack.setCurrentlyDispatching(
+                ExhaustedDataLoaderDispatchStrategy.CallStack.setDataLoaderToDispatch(0, false), true)
+        contendedCallStack.casFailuresRemaining.set(1)
+        strategy.finishedFetching(executionContext, rootParams)
+
+        Thread.sleep(200)
+
+        then:
+        batchLoaderInvocations.get() == 1
+    }
+
+    def "CAS retry in dispatchImpl early-exit path is exercised under contention"() {
+        given:
+        def doneLatch = new CountDownLatch(1)
+        AtomicInteger roundCount = new AtomicInteger()
+        def contendedCallStack = new ContendedCallStack()
+
+        def chainedBatchLoader = new BatchLoader<String, String>() {
+            @Override
+            CompletionStage<List<String>> load(List<String> keys) {
+                int round = roundCount.incrementAndGet()
+                if (round == 1) {
+                    // During first batch, load another key to trigger second dispatch round
+                    dataLoaderRegistry.getDataLoader("testLoader").load("key2")
+                    strategy.newDataLoaderInvocation(null)
+                }
+                if (round == 2) {
+                    // Inject a CAS failure targeting the early-exit path. After round 2
+                    // completes, the recursive dispatchImpl sees dataLoaderToDispatch=false
+                    // and tries to set currentlyDispatching=false. The target newState is 0
+                    // (all bits cleared: no dispatching, no dataLoader pending, objectRunning=0).
+                    contendedCallStack.failOnNewState = ExhaustedDataLoaderDispatchStrategy.CallStack.setCurrentlyDispatching(0, false)
+                    contendedCallStack.casFailuresRemaining.set(1)
+                    doneLatch.countDown()
+                }
+                return CompletableFuture.completedFuture(keys)
+            }
+        }
+        setupStrategyWithCallStack(chainedBatchLoader, contendedCallStack)
+        dataLoaderRegistry.getDataLoader("testLoader").load("key1")
+
+        when:
+        strategy.executionStrategy(executionContext, rootParams, 1)
+        strategy.newDataLoaderInvocation(null)
+        strategy.finishedFetching(executionContext, rootParams)
+
+        def completed = doneLatch.await(2, TimeUnit.SECONDS)
+
+        then:
+        completed
+        roundCount.get() == 2
+    }
+}
diff --git a/src/test/groovy/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategyTest.groovy b/src/test/groovy/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategyTest.groovy
new file mode 100644
index 0000000000..b67dc7e37b
--- /dev/null
+++ b/src/test/groovy/graphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategyTest.groovy
@@ -0,0 +1,182 @@
+package graphql.execution.instrumentation.dataloader
+
+import graphql.EngineRunningState
+import graphql.ExecutionInput
+import graphql.GraphQLContext
+import graphql.Profiler
+import graphql.Scalars
+import graphql.execution.AsyncExecutionStrategy
+import graphql.execution.CoercedVariables
+import graphql.execution.ExecutionContextBuilder
+import graphql.execution.ExecutionId
+import graphql.execution.ExecutionStepInfo
+import graphql.execution.ExecutionStrategyParameters
+import graphql.execution.MergedSelectionSet
+import graphql.execution.NonNullableFieldValidator
+import graphql.execution.ResultPath
+import graphql.execution.ValueUnboxer
+import graphql.execution.instrumentation.SimplePerformantInstrumentation
+import graphql.schema.DataFetcher
+import graphql.schema.DataFetchingEnvironment
+import org.dataloader.DataLoaderRegistry
+import spock.lang.Specification
+
+import java.util.concurrent.CountDownLatch
+import java.util.concurrent.Executors
+import java.util.concurrent.TimeUnit
+import java.util.function.Supplier
+
+import static graphql.StarWarsSchema.starWarsSchema
+
+/**
+ * Tests for concurrency-dependent code paths in {@link PerLevelDataLoaderDispatchStrategy}
+ * that are otherwise non-deterministically covered by integration tests.
+ */
+class PerLevelDataLoaderDispatchStrategyTest extends Specification {
+
+    def executionContext
+    def strategy
+
+    void setup() {
+        def dummyStrategy = new AsyncExecutionStrategy()
+        def ei = ExecutionInput.newExecutionInput("{ hero { name } }").build()
+        def builder = ExecutionContextBuilder.newExecutionContextBuilder()
+                .instrumentation(SimplePerformantInstrumentation.INSTANCE)
+                .executionId(ExecutionId.from("test"))
+                .graphQLSchema(starWarsSchema)
+                .queryStrategy(dummyStrategy)
+                .mutationStrategy(dummyStrategy)
+                .subscriptionStrategy(dummyStrategy)
+                .coercedVariables(CoercedVariables.emptyVariables())
+                .graphQLContext(GraphQLContext.newContext().build())
+                .executionInput(ei)
+                .root("root")
+                .dataLoaderRegistry(new DataLoaderRegistry())
+                .locale(Locale.getDefault())
+                .valueUnboxer(ValueUnboxer.DEFAULT)
+                .profiler(Profiler.NO_OP)
+                .engineRunningState(new EngineRunningState(ei, Profiler.NO_OP))
+        executionContext = builder.build()
+        strategy = new PerLevelDataLoaderDispatchStrategy(executionContext)
+    }
+
+    private ExecutionStrategyParameters paramsAtLevel(int level) {
+        def path = ResultPath.rootPath()
+        for (int i = 0; i < level; i++) {
+            path = path.segment("f" + i)
+        }
+        return ExecutionStrategyParameters.newParameters()
+                .executionStepInfo(ExecutionStepInfo.newExecutionStepInfo()
+                        .type(Scalars.GraphQLString)
+                        .path(path)
+                        .build())
+                .fields(MergedSelectionSet.newMergedSelectionSet().build())
+                .nonNullFieldValidator(new NonNullableFieldValidator(executionContext))
+                .path(path)
+                .build()
+    }
+
+    def "markLevelAsDispatchedIfReady returns false when level already dispatched"() {
+        given:
+        def callStack = strategy.initialCallStack
+        def dispatchedLevels = callStack.dispatchedLevels
+
+        and: "set up level 0 via executionStrategy and dispatch level 1 via fieldFetched"
+        def rootParams = paramsAtLevel(0)
+        strategy.executionStrategy(executionContext, rootParams, 1)
+        def level1Params = paramsAtLevel(1)
+        strategy.fieldFetched(executionContext, level1Params,
+                { env -> null } as DataFetcher,
+                "value",
+                { -> null } as Supplier<DataFetchingEnvironment>)
+
+        and: "make isLevelReady(2) return true by matching completionFinished to executeObjectCalls at level 0"
+        def state0 = callStack.get(0)
+        callStack.tryUpdateLevel(0, state0, state0.increaseHappenedCompletionFinishedCount())
+
+        expect:
+        dispatchedLevels.contains(1)
+
+        when: "first dispatch of level 2"
+        def firstResult = strategy.markLevelAsDispatchedIfReady(2, callStack)
+
+        then:
+        firstResult
+        dispatchedLevels.contains(2)
+
+        when: "second dispatch of level 2 (simulates another thread arriving late)"
+        def secondResult = strategy.markLevelAsDispatchedIfReady(2, callStack)
+
+        then:
+        !secondResult
+    }
+
+    def "concurrent onCompletionFinished races to dispatch same level"() {
+        given:
+        def rootParams = paramsAtLevel(0)
+        strategy.executionStrategy(executionContext, rootParams, 1)
+
+        and: "increment executeObjectCalls at level 0 from 1 to 2"
+        def level0Params = paramsAtLevel(0)
+        strategy.executeObject(executionContext, level0Params, 1)
+
+        and: "dispatch level 1 via fieldFetched"
+        def level1Params = paramsAtLevel(1)
+        strategy.fieldFetched(executionContext, level1Params,
+                { env -> null } as DataFetcher,
+                "value",
+                { -> null } as Supplier<DataFetchingEnvironment>)
+
+        when: "two threads concurrently complete level 0"
+        def startLatch = new CountDownLatch(1)
+        def executor = Executors.newFixedThreadPool(2)
+
+        def task = {
+            startLatch.await()
+            strategy.executeObjectOnFieldValuesInfo(Collections.emptyList(), level0Params)
+        } as Runnable
+
+        executor.submit(task)
+        executor.submit(task)
+        startLatch.countDown()
+        executor.shutdown()
+        executor.awaitTermination(5, TimeUnit.SECONDS)
+
+        then: "level 2 is dispatched exactly once (regardless of which thread won)"
+        strategy.initialCallStack.dispatchedLevels.contains(2)
+    }
+
+    def "executeObjectOnFieldValuesException calls onCompletionFinished"() {
+        given:
+        def rootParams = paramsAtLevel(0)
+        strategy.executionStrategy(executionContext, rootParams, 1)
+
+        and: "dispatch level 1 via fieldFetched"
+        def level1Params = paramsAtLevel(1)
+        strategy.fieldFetched(executionContext, level1Params,
+                { env -> null } as DataFetcher,
+                "value",
+                { -> null } as Supplier<DataFetchingEnvironment>)
+
+        when:
+        def level2Params = paramsAtLevel(2)
+        strategy.executeObjectOnFieldValuesException(
+                new RuntimeException("test error"), level2Params)
+
+        then:
+        strategy.initialCallStack.get(2).happenedCompletionFinishedCount > 0
+    }
+
+    def "executionStrategyOnFieldValuesException calls onCompletionFinished"() {
+        given:
+        def rootParams = paramsAtLevel(0)
+        strategy.executionStrategy(executionContext, rootParams, 1)
+
+        when:
+        strategy.executionStrategyOnFieldValuesException(
+                new RuntimeException("test error"), rootParams)
+
+        then:
+        strategy.initialCallStack.get(0).happenedCompletionFinishedCount > 0
+    }
+}
diff --git a/src/test/groovy/graphql/execution/preparsed/PreparsedDocumentEntryTest.groovy b/src/test/groovy/graphql/execution/preparsed/PreparsedDocumentEntryTest.groovy
index 423b557b7c..937e1024be 100644
--- a/src/test/groovy/graphql/execution/preparsed/PreparsedDocumentEntryTest.groovy
+++ b/src/test/groovy/graphql/execution/preparsed/PreparsedDocumentEntryTest.groovy
@@ -19,7 +19,7 @@ class PreparsedDocumentEntryTest extends Specification {
 
         then:
         docEntry.document == document
-        docEntry.errors == null
+        docEntry.errors == []
     }
 
     def "Ensure a null document throws Exception"() {
diff --git a/src/test/groovy/graphql/execution/reactive/CompletionStageOrderedSubscriberTest.groovy b/src/test/groovy/graphql/execution/reactive/CompletionStageOrderedSubscriberTest.groovy
index 3438a87d06..27ba2640ba 100644
--- a/src/test/groovy/graphql/execution/reactive/CompletionStageOrderedSubscriberTest.groovy
+++ b/src/test/groovy/graphql/execution/reactive/CompletionStageOrderedSubscriberTest.groovy
@@ -5,7 +5,11 @@ import graphql.execution.pubsub.CapturingSubscription
 import org.reactivestreams.Subscriber
 
 import java.util.concurrent.CompletableFuture
+import java.util.concurrent.CompletionException
 import java.util.concurrent.CompletionStage
+import java.util.function.BiConsumer
+import java.util.function.BiFunction
+import java.util.function.Consumer
 import java.util.function.Function
 
 class CompletionStageOrderedSubscriberTest extends CompletionStageSubscriberTest {
@@ -19,4 +23,86 @@ class CompletionStageOrderedSubscriberTest extends CompletionStageSubscriberTest
     protected ArrayList<String> expectedOrderingOfAsyncCompletion() {
         return ["0", "1", "2", "3"]
     }
+
+    /**
+     * A CompletableFuture that is already completed exceptionally but suppresses whenComplete
+     * callbacks. This simulates the race condition where a CF fails but its whenComplete callback
+     * has not yet run, so another CF's callback discovers the failure during queue drain via cf.join().
+     */
+    static class SilentlyFailedFuture<T> extends CompletableFuture<T> {
+        SilentlyFailedFuture(Throwable ex) {
+            super.completeExceptionally(ex)
+        }
+
+        @Override
+        CompletableFuture<T> whenComplete(BiConsumer<? super T, ? super Throwable> action) {
+            // Return a new never-completing future instead of registering the callback.
+            // This simulates the race: the CF is done but its callback hasn't fired yet.
+            return new CompletableFuture<>()
+        }
+    }
+
+    def "handles exceptionally completed CF discovered during ordered queue drain (cfExceptionUnwrap)"() {
+        given: "a subscriber with a mapper that returns a silently-failed CF for item 0 and a normal CF for item 1"
+        def capturingSubscriber = new CapturingSubscriber<>()
+        def subscription = new CapturingSubscription()
+
+        def originalException = new RuntimeException("boom")
+        // Item 0: already failed, but whenComplete callback is suppressed
+        def silentlyFailed = new SilentlyFailedFuture<String>(originalException)
+        // Item 1: completes normally and immediately
+        def normalCf = CompletableFuture.completedFuture("one")
+
+        int callCount = 0
+        Function<Integer, CompletionStage<String>> mapper = { Integer i ->
+            if (callCount++ == 0) return silentlyFailed
+            return normalCf
+        }
+
+        def subscriber = new CompletionStageOrderedSubscriber<Integer, String>(mapper, capturingSubscriber)
+
+        when: "we subscribe and send two items"
+        subscriber.onSubscribe(subscription)
+        // Item 0: silently-failed CF is added to the queue; its whenComplete does nothing
+        subscriber.onNext(0)
+        // Item 1: normal CF completes immediately; its whenComplete fires and calls
+        // emptyInFlightQueueIfWeCan, which drains from the head and hits silentlyFailed.join()
+        subscriber.onNext(1)
+
+        then: "the downstream subscriber receives onError with the unwrapped original exception"
+        capturingSubscriber.isCompletedExceptionally()
+        // cfExceptionUnwrap should unwrap the CompletionException to the original cause
+        capturingSubscriber.throwable == originalException
+        capturingSubscriber.events == []
+    }
+
+    def "handles exceptionally completed CF when exception is not a CompletionException"() {
+        given: "a subscriber where item 0 fails with a plain RuntimeException (not CompletionException)"
+        def capturingSubscriber = new CapturingSubscriber<>()
+        def subscription = new CapturingSubscription()
+
+        // Use completeExceptionally with a CompletionException that has no cause,
+        // so cfExceptionUnwrap returns it as-is
+        def exceptionWithoutCause = new CompletionException("no cause", null)
+        def silentlyFailed = new SilentlyFailedFuture<String>(exceptionWithoutCause)
+        def normalCf = CompletableFuture.completedFuture("one")
+
+        int callCount = 0
+        Function<Integer, CompletionStage<String>> mapper = { Integer i ->
+            if (callCount++ == 0) return silentlyFailed
+            return normalCf
+        }
+
+        def subscriber = new CompletionStageOrderedSubscriber<Integer, String>(mapper, capturingSubscriber)
+
+        when:
+        subscriber.onSubscribe(subscription)
+        subscriber.onNext(0)
+        subscriber.onNext(1)
+
+        then: "CompletionException without a cause is passed through (wrapped in another CompletionException by join)"
+        capturingSubscriber.isCompletedExceptionally()
+        // join() wraps in CompletionException; cfExceptionUnwrap unwraps to the original CompletionException
+        capturingSubscriber.throwable == exceptionWithoutCause
+    }
 }
diff --git a/src/test/groovy/graphql/execution/reactive/tck/CompletionStageMappingOrderedPublisherRandomCompleteTckVerificationTest.java b/src/test/groovy/graphql/execution/reactive/tck/CompletionStageMappingOrderedPublisherRandomCompleteTckVerificationTest.java
index 19ebffc466..1dd0a08cb1 100644
--- a/src/test/groovy/graphql/execution/reactive/tck/CompletionStageMappingOrderedPublisherRandomCompleteTckVerificationTest.java
+++ b/src/test/groovy/graphql/execution/reactive/tck/CompletionStageMappingOrderedPublisherRandomCompleteTckVerificationTest.java
@@ -12,11 +12,16 @@
 import java.util.Random;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 import java.util.function.Function;
 
 /**
  * This uses the reactive streams TCK to test that our CompletionStageMappingPublisher meets spec
- * when it's got CFs that complete at different times
+ * when it's got CFs that complete at different times.
+ * <p>
+ * Uses a shared single-thread executor per publisher so CFs complete sequentially — see
+ * CompletionStageMappingOrderedPublisherTckVerificationTest for details on why.
  */
 @Test
 public class CompletionStageMappingOrderedPublisherRandomCompleteTckVerificationTest extends PublisherVerification<String> {
@@ -49,6 +54,7 @@ public boolean skipStochasticTests() {
 
     @NonNull
     private static Function<Integer, CompletionStage<String>> mapperFunc() {
+        ExecutorService executor = Executors.newSingleThreadExecutor();
         return i -> CompletableFuture.supplyAsync(() -> {
             int ms = rand(0, 5);
             try {
@@ -57,7 +63,7 @@ private static Function<Integer, CompletionStage<String>> mapperFunc() {
                 throw new RuntimeException(e);
             }
             return i + "!";
-        });
+        }, executor);
     }
 
     static Random rn = new Random();
diff --git a/src/test/groovy/graphql/execution/reactive/tck/CompletionStageMappingOrderedPublisherTckVerificationTest.java b/src/test/groovy/graphql/execution/reactive/tck/CompletionStageMappingOrderedPublisherTckVerificationTest.java
index b1b8689190..bdd45ae082 100644
--- a/src/test/groovy/graphql/execution/reactive/tck/CompletionStageMappingOrderedPublisherTckVerificationTest.java
+++ b/src/test/groovy/graphql/execution/reactive/tck/CompletionStageMappingOrderedPublisherTckVerificationTest.java
@@ -10,12 +10,18 @@
 import java.time.Duration;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.function.Function;
 
 /**
  * This uses the reactive streams TCK to test that our CompletionStageMappingPublisher meets spec
- * when it's got CFs that complete off thread
+ * when it's got CFs that complete off thread.
+ * <p>
+ * Uses a shared single-thread executor per publisher so CFs complete sequentially.
+ * The ordered subscriber drains completed CFs in a while loop — with concurrent executors,
+ * multiple CFs can complete before the drain starts, causing multiple onNext calls on the
+ * same thread which the TCK flags as a spec303 (unbounded recursion) violation.
  */
 @Test
 public class CompletionStageMappingOrderedPublisherTckVerificationTest extends PublisherVerification<String> {
@@ -32,14 +38,16 @@ public long maxElementsFromPublisher() {
     @Override
     public Publisher<String> createPublisher(long elements) {
         Publisher<Integer> publisher = Flowable.range(0, (int) elements);
-        Function<Integer, CompletionStage<String>> mapper = i -> CompletableFuture.supplyAsync(() -> i + "!", Executors.newSingleThreadExecutor());
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+        Function<Integer, CompletionStage<String>> mapper = i -> CompletableFuture.supplyAsync(() -> i + "!", executor);
         return new CompletionStageMappingOrderedPublisher<>(publisher, mapper);
     }
 
     @Override
     public Publisher<String> createFailedPublisher() {
         Publisher<Integer> publisher = Flowable.error(() -> new RuntimeException("Bang"));
-        Function<Integer, CompletionStage<String>> mapper = i -> CompletableFuture.supplyAsync(() -> i + "!", Executors.newSingleThreadExecutor());
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+        Function<Integer, CompletionStage<String>> mapper = i -> CompletableFuture.supplyAsync(() -> i + "!", executor);
         return new CompletionStageMappingOrderedPublisher<>(publisher, mapper);
     }
 
diff --git a/src/test/groovy/graphql/execution/reactive/tck/CompletionStageMappingPublisherRandomCompleteTckVerificationTest.java b/src/test/groovy/graphql/execution/reactive/tck/CompletionStageMappingPublisherRandomCompleteTckVerificationTest.java
index 889b18eeeb..8446d26019 100644
--- a/src/test/groovy/graphql/execution/reactive/tck/CompletionStageMappingPublisherRandomCompleteTckVerificationTest.java
+++ b/src/test/groovy/graphql/execution/reactive/tck/CompletionStageMappingPublisherRandomCompleteTckVerificationTest.java
@@ -12,6 +12,8 @@
 import java.util.Random;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 import java.util.function.Function;
 
 /**
@@ -49,6 +51,7 @@ public boolean skipStochasticTests() {
 
     @NonNull
     private static Function<Integer, CompletionStage<String>> mapperFunc() {
+        ExecutorService executor = Executors.newSingleThreadExecutor();
         return i -> CompletableFuture.supplyAsync(() -> {
             int ms = rand(0, 5);
             try {
@@ -57,7 +60,7 @@ private static Function<Integer, CompletionStage<String>> mapperFunc() {
                 throw new RuntimeException(e);
             }
             return i + "!";
-        });
+        }, executor);
     }
 
     static Random rn = new Random();
diff --git a/src/test/groovy/graphql/execution/reactive/tck/CompletionStageMappingPublisherTckVerificationTest.java b/src/test/groovy/graphql/execution/reactive/tck/CompletionStageMappingPublisherTckVerificationTest.java
index f68c7d3fab..d2796200da 100644
--- a/src/test/groovy/graphql/execution/reactive/tck/CompletionStageMappingPublisherTckVerificationTest.java
+++ b/src/test/groovy/graphql/execution/reactive/tck/CompletionStageMappingPublisherTckVerificationTest.java
@@ -10,6 +10,7 @@
 import java.time.Duration;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
+import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.function.Function;
 
@@ -32,14 +33,16 @@ public long maxElementsFromPublisher() {
     @Override
     public Publisher<String> createPublisher(long elements) {
         Publisher<Integer> publisher = Flowable.range(0, (int) elements);
-        Function<Integer, CompletionStage<String>> mapper = i -> CompletableFuture.supplyAsync(() -> i + "!", Executors.newSingleThreadExecutor());
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+        Function<Integer, CompletionStage<String>> mapper = i -> CompletableFuture.supplyAsync(() -> i + "!", executor);
         return new CompletionStageMappingPublisher<>(publisher, mapper);
     }
 
     @Override
     public Publisher<String> createFailedPublisher() {
         Publisher<Integer> publisher = Flowable.error(() -> new RuntimeException("Bang"));
-        Function<Integer, CompletionStage<String>> mapper = i -> CompletableFuture.supplyAsync(() -> i + "!");
+        ExecutorService executor = Executors.newSingleThreadExecutor();
+        Function<Integer, CompletionStage<String>> mapper = i -> CompletableFuture.supplyAsync(() -> i + "!", executor);
         return new CompletionStageMappingPublisher<>(publisher, mapper);
     }
 
diff --git a/src/test/groovy/graphql/introspection/GoodFaithIntrospectionTest.groovy b/src/test/groovy/graphql/introspection/GoodFaithIntrospectionTest.groovy
index c2d9b2dc87..9da21c42be 100644
--- a/src/test/groovy/graphql/introspection/GoodFaithIntrospectionTest.groovy
+++ b/src/test/groovy/graphql/introspection/GoodFaithIntrospectionTest.groovy
@@ -2,10 +2,13 @@ package graphql.introspection
 
 import graphql.ExecutionInput
 import graphql.ExecutionResult
+import graphql.ParseAndValidate
 import graphql.TestUtil
 import graphql.execution.CoercedVariables
 import graphql.language.Document
 import graphql.normalized.ExecutableNormalizedOperationFactory
+import graphql.validation.OperationValidationRule
+import graphql.validation.QueryComplexityLimits
 import spock.lang.Specification
 
 class GoodFaithIntrospectionTest extends Specification {
@@ -142,6 +145,24 @@ class GoodFaithIntrospectionTest extends Specification {
         er.errors.isEmpty()
     }
 
+    def "disabling good faith composes with custom validation rule predicates"() {
+        given:
+        // Custom predicate that disables a specific rule
+        def customPredicate = { OperationValidationRule rule -> rule != OperationValidationRule.KNOWN_ARGUMENT_NAMES } as java.util.function.Predicate
+
+        when:
+        def context = [
+                (GoodFaithIntrospection.GOOD_FAITH_INTROSPECTION_DISABLED)    : true,
+                (ParseAndValidate.INTERNAL_VALIDATION_PREDICATE_HINT)         : customPredicate
+        ]
+        ExecutionInput executionInput = ExecutionInput.newExecutionInput("{ normalField }")
+                .graphQLContext(context).build()
+        ExecutionResult er = graphql.execute(executionInput)
+
+        then:
+        er.errors.isEmpty()
+    }
+
     def "can be disabled per request"() {
         when:
         def context = [(GoodFaithIntrospection.GOOD_FAITH_INTROSPECTION_DISABLED): true]
@@ -188,6 +209,100 @@ class GoodFaithIntrospectionTest extends Specification {
         100 | GoodFaithIntrospection.BadFaithIntrospectionError.class
     }
 
+    def "introspection via inline fragment on Query is detected as bad faith"() {
+        def query = """
+            query badActor {
+                ...on Query {
+                    __schema{types{fields{type{fields{type{fields{type{fields{type{name}}}}}}}}}}
+                }
+            }
+        """
+
+        when:
+        ExecutionResult er = graphql.execute(query)
+
+        then:
+        !er.errors.isEmpty()
+        er.errors[0] instanceof GoodFaithIntrospection.BadFaithIntrospectionError
+    }
+
+    def "introspection via fragment spread is detected as bad faith"() {
+        def query = """
+            query badActor {
+                ...IntrospectionFragment
+            }
+            fragment IntrospectionFragment on Query {
+                __schema{types{fields{type{fields{type{fields{type{fields{type{name}}}}}}}}}}
+            }
+        """
+
+        when:
+        ExecutionResult er = graphql.execute(query)
+
+        then:
+        !er.errors.isEmpty()
+        er.errors[0] instanceof GoodFaithIntrospection.BadFaithIntrospectionError
+    }
+
+    def "good faith limits are applied on top of custom user limits"() {
+        given:
+        def limits = QueryComplexityLimits.newLimits().maxFieldsCount(200).maxDepth(15).build()
+        def executionInput = ExecutionInput.newExecutionInput(IntrospectionQuery.INTROSPECTION_QUERY)
+                .graphQLContext([(QueryComplexityLimits.KEY): limits])
+                .build()
+
+        when:
+        ExecutionResult er = graphql.execute(executionInput)
+
+        then:
+        er.errors.isEmpty()
+    }
+
+    def "introspection query exceeding field count limit is detected as bad faith"() {
+        given:
+        // Build a wide introspection query that exceeds GOOD_FAITH_MAX_FIELDS_COUNT (500)
+        // using non-cycle-forming fields (aliases of 'name') so the tooManyFields check
+        // does not fire first, exercising the tooBigOperation code path instead
+        def sb = new StringBuilder()
+        sb.append("query { __schema { types { ")
+        for (int i = 0; i < 510; i++) {
+            sb.append("a${i}: name ")
+        }
+        sb.append("} } }")
+
+        when:
+        ExecutionResult er = graphql.execute(sb.toString())
+
+        then:
+        !er.errors.isEmpty()
+        er.errors[0] instanceof GoodFaithIntrospection.BadFaithIntrospectionError
+        er.errors[0].message.contains("too big")
+    }
+
+    def "introspection query exceeding depth limit is detected as bad faith"() {
+        given:
+        // Build a deep introspection query using ofType (not a cycle-forming field)
+        // that exceeds GOOD_FAITH_MAX_DEPTH_COUNT (20)
+        def sb = new StringBuilder()
+        sb.append("query { __schema { types { ")
+        for (int i = 0; i < 20; i++) {
+            sb.append("ofType { ")
+        }
+        sb.append("name ")
+        for (int i = 0; i < 20; i++) {
+            sb.append("} ")
+        }
+        sb.append("} } }")
+
+        when:
+        ExecutionResult er = graphql.execute(sb.toString())
+
+        then:
+        !er.errors.isEmpty()
+        er.errors[0] instanceof GoodFaithIntrospection.BadFaithIntrospectionError
+        er.errors[0].message.contains("too big")
+    }
+
     String createDeepQuery(int depth = 25) {
         def result = """
 query test {
diff --git a/src/test/groovy/graphql/language/NodeParentTreeTest.groovy b/src/test/groovy/graphql/language/NodeParentTreeTest.groovy
index b1af0ef696..ad29c28bdc 100644
--- a/src/test/groovy/graphql/language/NodeParentTreeTest.groovy
+++ b/src/test/groovy/graphql/language/NodeParentTreeTest.groovy
@@ -7,7 +7,7 @@ class NodeParentTreeTest extends Specification {
 
     def strValue = StringValue.newStringValue("123").build()
     def argument = Argument.newArgument("arg", strValue).build()
-    def fieldDef = FieldDefinition.newFieldDefinition().name("field").build()
+    def fieldDef = FieldDefinition.newFieldDefinition().name("field").type(new TypeName("String")).build()
     def objectTypeDef = ObjectTypeDefinition.newObjectTypeDefinition().name("object").build()
 
     def "basic hierarchy"() {
diff --git a/src/test/groovy/graphql/language/NodeTraverserTest.groovy b/src/test/groovy/graphql/language/NodeTraverserTest.groovy
index 9929f43ab5..7320a41ef3 100644
--- a/src/test/groovy/graphql/language/NodeTraverserTest.groovy
+++ b/src/test/groovy/graphql/language/NodeTraverserTest.groovy
@@ -140,7 +140,7 @@ class NodeTraverserTest extends Specification {
                 context.setAccumulate(node)
             }
         }
-        def field = Field.newField().build()
+        def field = Field.newField().name("dummy").build()
         when:
         def result = NodeTraverser.oneVisitWithResult(field, visitor);
         then:
diff --git a/src/test/groovy/graphql/language/NodeVisitorStubTest.groovy b/src/test/groovy/graphql/language/NodeVisitorStubTest.groovy
index df165b23cd..cfe60674a5 100644
--- a/src/test/groovy/graphql/language/NodeVisitorStubTest.groovy
+++ b/src/test/groovy/graphql/language/NodeVisitorStubTest.groovy
@@ -24,8 +24,8 @@ class NodeVisitorStubTest extends Specification {
 
         where:
         node                                       | visitMethod
-        Field.newField().build()                   | 'visitField'
-        FragmentSpread.newFragmentSpread().build() | 'visitFragmentSpread'
+        Field.newField().name("f").build()                   | 'visitField'
+        FragmentSpread.newFragmentSpread().name("f").build() | 'visitFragmentSpread'
         InlineFragment.newInlineFragment().build() | 'visitInlineFragment'
 
     }
@@ -71,7 +71,7 @@ class NodeVisitorStubTest extends Specification {
         where:
         node                                                 | visitMethod
         OperationDefinition.newOperationDefinition().build() | 'visitOperationDefinition'
-        FragmentDefinition.newFragmentDefinition().build()   | 'visitFragmentDefinition'
+        FragmentDefinition.newFragmentDefinition().name("f").typeCondition(new TypeName("T")).selectionSet(SelectionSet.newSelectionSet().build()).build() | 'visitFragmentDefinition'
         new DirectiveDefinition("")                          | 'visitDirectiveDefinition'
         SchemaDefinition.newSchemaDefinition().build()       | 'visitSchemaDefinition'
     }
@@ -137,7 +137,7 @@ class NodeVisitorStubTest extends Specification {
         new DirectiveLocation("")                                    | 'visitDirectiveLocation'
         Document.newDocument().build()                               | 'visitDocument'
         new EnumValueDefinition("")                                  | 'visitEnumValueDefinition'
-        FieldDefinition.newFieldDefinition().build()                 | 'visitFieldDefinition'
+        FieldDefinition.newFieldDefinition().name("f").type(new TypeName("T")).build() | 'visitFieldDefinition'
         InputValueDefinition.newInputValueDefinition().build()       | 'visitInputValueDefinition'
         InputValueDefinition.newInputValueDefinition().build()       | 'visitInputValueDefinition'
         new ObjectField("a", IntValue.of(1))                         | 'visitObjectField'
@@ -148,7 +148,7 @@ class NodeVisitorStubTest extends Specification {
         new StringValue("")                                          | 'visitValue'
         OperationDefinition.newOperationDefinition().build()         | 'visitDefinition'
         new UnionTypeDefinition("")                                  | 'visitTypeDefinition'
-        Field.newField().build()                                     | 'visitSelection'
+        Field.newField().name("f").build()                             | 'visitSelection'
         NonNullType.newNonNullType().build()                         | 'visitType'
 
     }
diff --git a/src/test/groovy/graphql/normalized/ExecutableNormalizedOperationFactoryTest.groovy b/src/test/groovy/graphql/normalized/ExecutableNormalizedOperationFactoryTest.groovy
index a04c74f954..7463031d49 100644
--- a/src/test/groovy/graphql/normalized/ExecutableNormalizedOperationFactoryTest.groovy
+++ b/src/test/groovy/graphql/normalized/ExecutableNormalizedOperationFactoryTest.groovy
@@ -20,6 +20,7 @@ import graphql.util.TraversalControl
 import graphql.util.Traverser
 import graphql.util.TraverserContext
 import graphql.util.TraverserVisitorStub
+import graphql.validation.QueryComplexityLimits
 import spock.lang.Specification
 
 import java.util.stream.Collectors
@@ -33,6 +34,14 @@ import static graphql.schema.FieldCoordinates.coordinates
 class ExecutableNormalizedOperationFactoryTest extends Specification {
     static boolean deferSupport
 
+    def setup() {
+        // Disable validation complexity limits so ENO limits can be tested
+        QueryComplexityLimits.setDefaultLimits(QueryComplexityLimits.NONE)
+    }
+
+    def cleanup() {
+        QueryComplexityLimits.setDefaultLimits(QueryComplexityLimits.DEFAULT)
+    }
 
     def "test"() {
         String schema = """
diff --git a/src/test/groovy/graphql/schema/DataFetchingEnvironmentImplTest.groovy b/src/test/groovy/graphql/schema/DataFetchingEnvironmentImplTest.groovy
index 561b881bd2..8c401f0d63 100644
--- a/src/test/groovy/graphql/schema/DataFetchingEnvironmentImplTest.groovy
+++ b/src/test/groovy/graphql/schema/DataFetchingEnvironmentImplTest.groovy
@@ -9,6 +9,7 @@ import graphql.language.Argument
 import graphql.language.Field
 import graphql.language.FragmentDefinition
 import graphql.language.OperationDefinition
+import graphql.language.SelectionSet
 import graphql.language.StringValue
 import graphql.language.TypeName
 import org.dataloader.BatchLoader
@@ -26,10 +27,13 @@ import static graphql.schema.DataFetchingEnvironmentImpl.newDataFetchingEnvironm
 
 class DataFetchingEnvironmentImplTest extends Specification {
 
-    def frag = FragmentDefinition.newFragmentDefinition().name("frag").typeCondition(new TypeName("t")).build()
+    def frag = FragmentDefinition.newFragmentDefinition().name("frag").typeCondition(new TypeName("t")).selectionSet(SelectionSet.newSelectionSet().build()).build()
 
     def dataLoader = DataLoaderFactory.newDataLoader({ keys -> CompletableFuture.completedFuture(keys) } as BatchLoader)
-    def operationDefinition = new OperationDefinition("q")
+    def operationDefinition = OperationDefinition.newOperationDefinition()
+            .name("q")
+            .selectionSet(SelectionSet.newSelectionSet().selection(new Field("f")).build())
+            .build()
     def document = toDocument("{ f }")
     def executionId = ExecutionId.from("123")
     def fragmentByName = [frag: frag]
diff --git a/src/test/groovy/graphql/schema/FastBuilderTest.groovy b/src/test/groovy/graphql/schema/FastBuilderTest.groovy
index 795abc3969..3312300c52 100644
--- a/src/test/groovy/graphql/schema/FastBuilderTest.groovy
+++ b/src/test/groovy/graphql/schema/FastBuilderTest.groovy
@@ -3,6 +3,8 @@ package graphql.schema
 import graphql.AssertException
 import graphql.Scalars
 import graphql.introspection.Introspection
+import graphql.language.EnumValue
+import graphql.schema.validation.InvalidSchemaException
 import spock.lang.Specification
 
 import static graphql.Scalars.GraphQLString
@@ -11,6 +13,7 @@ import static graphql.schema.GraphQLDirective.newDirective
 import static graphql.schema.GraphQLAppliedDirective.newDirective as newAppliedDirective
 import static graphql.schema.GraphQLAppliedDirectiveArgument.newArgument as newAppliedArgument
 import static graphql.schema.GraphQLEnumType.newEnum
+import static graphql.schema.GraphQLEnumValueDefinition.newEnumValueDefinition
 import static graphql.schema.GraphQLFieldDefinition.newFieldDefinition
 import static graphql.schema.GraphQLInputObjectField.newInputObjectField
 import static graphql.schema.GraphQLInputObjectType.newInputObject
@@ -2108,4 +2111,261 @@ class FastBuilderTest extends Specification {
         def searchField = schema.queryType.getFieldDefinition("search")
         searchField.getArgument("filter").getType() == filterInput
     }
+
+    def "applied directive on directive definition argument with type-ref enum arg resolves correctly"() {
+        given: "an enum type used as the applied directive's argument type"
+        def colorEnum = newEnum()
+                .name("Color")
+                .value("RED")
+                .value("GREEN")
+                .build()
+
+        and: "a helper directive whose arg type is Color — applied to directive definition args"
+        def annotateDirective = newDirective()
+                .name("annotate")
+                .validLocation(Introspection.DirectiveLocation.ARGUMENT_DEFINITION)
+                .argument(newArgument()
+                        .name("color")
+                        .type(typeRef("Color")))
+                .build()
+
+        and: "an applied @annotate on a directive definition argument, with unresolved type ref"
+        def appliedAnnotate = newAppliedDirective()
+                .name("annotate")
+                .argument(newAppliedArgument()
+                        .name("color")
+                        .type(typeRef("Color"))
+                        .valueLiteral(new EnumValue("GREEN"))
+                        .build())
+                .build()
+
+        and: "a main directive whose argument carries the applied @annotate"
+        def mainDirective = newDirective()
+                .name("main")
+                .validLocation(Introspection.DirectiveLocation.FIELD_DEFINITION)
+                .argument(newArgument()
+                        .name("arg")
+                        .type(GraphQLString)
+                        .withAppliedDirective(appliedAnnotate))
+                .build()
+
+        and: "a simple query type"
+        def queryType = newObject()
+                .name("Query")
+                .field(newFieldDefinition()
+                        .name("field")
+                        .type(GraphQLString))
+                .build()
+
+        when: "building with FastBuilder and validation enabled"
+        def schema = new GraphQLSchema.FastBuilder(
+                GraphQLCodeRegistry.newCodeRegistry(), queryType, null, null)
+                .addType(colorEnum)
+                .additionalDirective(annotateDirective)
+                .additionalDirective(mainDirective)
+                .withValidation(true)
+                .build()
+
+        then: "schema builds successfully and the applied directive arg type is resolved"
+        schema != null
+        def resolvedMain = schema.getDirective("main")
+        def mainArg = resolvedMain.getArgument("arg")
+        def resolvedApplied = mainArg.getAppliedDirective("annotate")
+        resolvedApplied != null
+        !(resolvedApplied.getArgument("color").type instanceof GraphQLTypeReference)
+        resolvedApplied.getArgument("color").type == colorEnum
+    }
+
+    // Regression tests for ShallowTypeRefCollector bug:
+    // Applied directives on field arguments and enum values were not scanned for type
+    // references, leaving GraphQLTypeReference unresolved and causing spurious
+    // InvalidSchemaException from AppliedDirectiveArgumentsAreValid validator.
+
+    def "applied directive on object type field argument with type-ref enum arg resolves correctly"() {
+        given: "an enum type used as a directive argument type"
+        def statusEnum = newEnum()
+                .name("Status")
+                .value("ACTIVE")
+                .value("INACTIVE")
+                .build()
+
+        and: "a directive definition referencing Status"
+        def metaDirective = newDirective()
+                .name("meta")
+                .validLocation(Introspection.DirectiveLocation.ARGUMENT_DEFINITION)
+                .argument(newArgument()
+                        .name("status")
+                        .type(typeRef("Status")))
+                .build()
+
+        and: "an applied directive on a field argument whose arg type is still a GraphQLTypeReference"
+        def appliedMeta = newAppliedDirective()
+                .name("meta")
+                .argument(newAppliedArgument()
+                        .name("status")
+                        .type(typeRef("Status"))
+                        .valueLiteral(new EnumValue("ACTIVE"))
+                        .build())
+                .build()
+
+        and: "query type with a field whose argument carries the applied directive"
+        def queryType = newObject()
+                .name("Query")
+                .field(newFieldDefinition()
+                        .name("field")
+                        .type(GraphQLString)
+                        .argument(newArgument()
+                                .name("arg")
+                                .type(GraphQLString)
+                                .withAppliedDirective(appliedMeta)))
+                .build()
+
+        when: "building with FastBuilder and validation enabled"
+        def schema = new GraphQLSchema.FastBuilder(
+                GraphQLCodeRegistry.newCodeRegistry(), queryType, null, null)
+                .addType(statusEnum)
+                .additionalDirective(metaDirective)
+                .withValidation(true)
+                .build()
+
+        then: "schema builds successfully and the applied directive arg type is resolved"
+        schema != null
+        def fieldArg = schema.queryType.getFieldDefinition("field").getArgument("arg")
+        def resolvedApplied = fieldArg.getAppliedDirective("meta")
+        resolvedApplied != null
+        !(resolvedApplied.getArgument("status").type instanceof GraphQLTypeReference)
+        resolvedApplied.getArgument("status").type == statusEnum
+    }
+
+    def "applied directive on interface field argument with type-ref enum arg resolves correctly"() {
+        given: "an enum type used as a directive argument type"
+        def statusEnum = newEnum()
+                .name("Status")
+                .value("ACTIVE")
+                .value("INACTIVE")
+                .build()
+
+        and: "a directive definition referencing Status"
+        def metaDirective = newDirective()
+                .name("meta")
+                .validLocation(Introspection.DirectiveLocation.ARGUMENT_DEFINITION)
+                .argument(newArgument()
+                        .name("status")
+                        .type(typeRef("Status")))
+                .build()
+
+        and: "an applied directive on an interface field argument with unresolved type ref"
+        def appliedMeta = newAppliedDirective()
+                .name("meta")
+                .argument(newAppliedArgument()
+                        .name("status")
+                        .type(typeRef("Status"))
+                        .valueLiteral(new EnumValue("ACTIVE"))
+                        .build())
+                .build()
+
+        and: "an interface type with a field argument that has the applied directive"
+        def nodeInterface = GraphQLInterfaceType.newInterface()
+                .name("Node")
+                .typeResolver { null }
+                .field(newFieldDefinition()
+                        .name("find")
+                        .type(GraphQLString)
+                        .argument(newArgument()
+                                .name("filter")
+                                .type(GraphQLString)
+                                .withAppliedDirective(appliedMeta)))
+                .build()
+
+        and: "a query type referencing the interface"
+        def queryType = newObject()
+                .name("Query")
+                .field(newFieldDefinition()
+                        .name("node")
+                        .type(typeRef("Node")))
+                .build()
+
+        when: "building with FastBuilder and validation enabled"
+        def schema = new GraphQLSchema.FastBuilder(
+                GraphQLCodeRegistry.newCodeRegistry(), queryType, null, null)
+                .addType(statusEnum)
+                .addType(nodeInterface)
+                .additionalDirective(metaDirective)
+                .withValidation(true)
+                .build()
+
+        then: "schema builds successfully and the applied directive arg type is resolved"
+        schema != null
+        def iface = schema.getType("Node") as GraphQLInterfaceType
+        def fieldArg = iface.getFieldDefinition("find").getArgument("filter")
+        def resolvedApplied = fieldArg.getAppliedDirective("meta")
+        resolvedApplied != null
+        !(resolvedApplied.getArgument("status").type instanceof GraphQLTypeReference)
+        resolvedApplied.getArgument("status").type == statusEnum
+    }
+
+    def "applied directive on enum value with type-ref enum arg resolves correctly"() {
+        given: "a Color enum type used as the directive argument type"
+        def colorEnum = newEnum()
+                .name("Color")
+                .value("RED")
+                .value("GREEN")
+                .build()
+
+        and: "a directive definition referencing Color"
+        def metaDirective = newDirective()
+                .name("meta")
+                .validLocation(Introspection.DirectiveLocation.ENUM_VALUE)
+                .argument(newArgument()
+                        .name("color")
+                        .type(typeRef("Color")))
+                .build()
+
+        and: "an applied directive on an enum value with unresolved type ref"
+        def appliedMeta = newAppliedDirective()
+                .name("meta")
+                .argument(newAppliedArgument()
+                        .name("color")
+                        .type(typeRef("Color"))
+                        .valueLiteral(new EnumValue("GREEN"))
+                        .build())
+                .build()
+
+        and: "an enum type whose values have the applied directive"
+        def statusEnum = newEnum()
+                .name("Status")
+                .value(newEnumValueDefinition()
+                        .name("ACTIVE")
+                        .value("ACTIVE")
+                        .withAppliedDirective(appliedMeta)
+                        .build())
+                .value("INACTIVE")
+                .build()
+
+        and: "a query type"
+        def queryType = newObject()
+                .name("Query")
+                .field(newFieldDefinition()
+                        .name("field")
+                        .type(GraphQLString))
+                .build()
+
+        when: "building with FastBuilder and validation enabled"
+        def schema = new GraphQLSchema.FastBuilder(
+                GraphQLCodeRegistry.newCodeRegistry(), queryType, null, null)
+                .addType(statusEnum)
+                .addType(colorEnum)
+                .additionalDirective(metaDirective)
+                .withValidation(true)
+                .build()
+
+        then: "schema builds successfully and the applied directive arg type is resolved"
+        schema != null
+        def resolvedStatus = schema.getType("Status") as GraphQLEnumType
+        def activeValue = resolvedStatus.getValue("ACTIVE")
+        def resolvedApplied = activeValue.getAppliedDirective("meta")
+        resolvedApplied != null
+        !(resolvedApplied.getArgument("color").type instanceof GraphQLTypeReference)
+        resolvedApplied.getArgument("color").type == colorEnum
+    }
 }
diff --git a/src/test/groovy/graphql/schema/PropertyDataFetcherTest.groovy b/src/test/groovy/graphql/schema/PropertyDataFetcherTest.groovy
index 7903f14229..d1bdbc94b5 100644
--- a/src/test/groovy/graphql/schema/PropertyDataFetcherTest.groovy
+++ b/src/test/groovy/graphql/schema/PropertyDataFetcherTest.groovy
@@ -7,6 +7,7 @@ import graphql.schema.fetching.ConfusedPojo
 import graphql.schema.somepackage.ClassWithDFEMethods
 import graphql.schema.somepackage.ClassWithInterfaces
 import graphql.schema.somepackage.ClassWithInteritanceAndInterfaces
+import graphql.schema.somepackage.InterfaceInheritanceHolder
 import graphql.schema.somepackage.RecordLikeClass
 import graphql.schema.somepackage.RecordLikeTwoClassesDown
 import graphql.schema.somepackage.TestClass
@@ -788,6 +789,124 @@ class PropertyDataFetcherTest extends Specification {
 
     class OtherObject extends BaseObject {}
 
+    def "fetch via public interface method on non-public class - issue 4278"() {
+        given:
+        // TreeMap.Entry is a package-private class implementing the public Map.Entry interface
+        // On Java 16+, setAccessible fails on JDK internal classes, so the only way to invoke
+        // getValue() is by finding it through the public Map.Entry interface
+        PropertyDataFetcherHelper.setUseLambdaFactory(false)
+        PropertyDataFetcher.clearReflectionCache()
+
+        def treeMap = new TreeMap<String, String>()
+        treeMap.put("testKey", "testValue")
+        def entry = treeMap.entrySet().iterator().next()
+        def environment = env("value", entry)
+
+        when:
+        def result = fetcher.get(environment)
+
+        then:
+        result == "testValue"
+
+        where:
+        fetcher                                  | _
+        new PropertyDataFetcher("value")         | _
+        SingletonPropertyDataFetcher.singleton() | _
+    }
+
+    def "fetch via public interface method on non-public class for key - issue 4278"() {
+        given:
+        PropertyDataFetcherHelper.setUseLambdaFactory(false)
+        PropertyDataFetcher.clearReflectionCache()
+
+        def treeMap = new TreeMap<String, String>()
+        treeMap.put("testKey", "testValue")
+        def entry = treeMap.entrySet().iterator().next()
+        def environment = env("key", entry)
+
+        when:
+        def result = fetcher.get(environment)
+
+        then:
+        result == "testKey"
+
+        where:
+        fetcher                                  | _
+        new PropertyDataFetcher("key")           | _
+        SingletonPropertyDataFetcher.singleton() | _
+    }
+
+    def "fetch method from public interface through package-private interface chain"() {
+        given:
+        // PackagePrivateChainImpl (package-private) implements PackagePrivateMiddleInterface (package-private)
+        // which extends PublicBaseInterface (public) — defines getBaseValue()
+        // The recursive interface search must traverse through the package-private middle interface
+        PropertyDataFetcherHelper.setUseLambdaFactory(false)
+        PropertyDataFetcher.clearReflectionCache()
+
+        def obj = InterfaceInheritanceHolder.createChainImpl()
+        def environment = env("baseValue", obj)
+
+        when:
+        def result = new PropertyDataFetcher("baseValue").get(environment)
+
+        then:
+        result == "baseValue"
+    }
+
+    def "fetch method through diamond interface inheritance"() {
+        given:
+        // DiamondImpl (package-private) implements both PackagePrivateBranchA and PackagePrivateBranchB
+        // Both are package-private interfaces extending PublicBaseInterface (public) — defines getBaseValue()
+        // The search must find getBaseValue() through either branch
+        PropertyDataFetcherHelper.setUseLambdaFactory(false)
+        PropertyDataFetcher.clearReflectionCache()
+
+        def obj = InterfaceInheritanceHolder.createDiamondImpl()
+
+        expect:
+        new PropertyDataFetcher(property).get(env(property, obj)) == expected
+
+        where:
+        property    | expected
+        "baseValue" | "diamondBaseValue"
+    }
+
+    def "fetch via public interface method with DataFetchingEnvironment parameter on non-public class"() {
+        given:
+        // PackagePrivateDfeImpl implements PublicDfeInterface which declares getDfeValue(DataFetchingEnvironment)
+        // This exercises the dfeInUse path in findMethodOnPublicInterfaces (lines 262-267)
+        PropertyDataFetcherHelper.setUseLambdaFactory(false)
+        PropertyDataFetcher.clearReflectionCache()
+
+        def obj = InterfaceInheritanceHolder.createDfeImpl()
+        def environment = env("dfeValue", obj)
+
+        when:
+        def result = new PropertyDataFetcher("dfeValue").get(environment)
+
+        then:
+        result == "dfeValue"
+    }
+
+    def "fetch via interface search hits NoSuchMethodException and continues to next interface"() {
+        given:
+        // PackagePrivateMultiInterfaceImpl implements PublicInterfaceWithoutTarget (no getBaseValue)
+        // and PublicBaseInterface (has getBaseValue). The search must hit NoSuchMethodException
+        // on the first interface and continue to find it on the second.
+        PropertyDataFetcherHelper.setUseLambdaFactory(false)
+        PropertyDataFetcher.clearReflectionCache()
+
+        def obj = InterfaceInheritanceHolder.createMultiInterfaceImpl()
+        def environment = env("baseValue", obj)
+
+        when:
+        def result = new PropertyDataFetcher("baseValue").get(environment)
+
+        then:
+        result == "foundViaSecondInterface"
+    }
+
     def "Can access private property from base class that starts with i in Turkish"() {
         // see https://github.com/graphql-java/graphql-java/issues/3385
         given:
diff --git a/src/test/groovy/graphql/schema/idl/FastSchemaGeneratorTest.groovy b/src/test/groovy/graphql/schema/idl/FastSchemaGeneratorTest.groovy
index 30c600ead2..bd362f76ac 100644
--- a/src/test/groovy/graphql/schema/idl/FastSchemaGeneratorTest.groovy
+++ b/src/test/groovy/graphql/schema/idl/FastSchemaGeneratorTest.groovy
@@ -329,4 +329,5 @@ class FastSchemaGeneratorTest extends Specification {
         notThrown(InvalidSchemaException)
         schema != null
     }
+
 }
diff --git a/src/test/groovy/graphql/schema/idl/SchemaPrinterTest.groovy b/src/test/groovy/graphql/schema/idl/SchemaPrinterTest.groovy
index 2870244328..ea4268043f 100644
--- a/src/test/groovy/graphql/schema/idl/SchemaPrinterTest.groovy
+++ b/src/test/groovy/graphql/schema/idl/SchemaPrinterTest.groovy
@@ -14,6 +14,7 @@ import graphql.language.IntValue
 import graphql.language.ScalarTypeDefinition
 import graphql.language.SchemaDefinition
 import graphql.language.StringValue
+import graphql.language.TypeName
 import graphql.schema.Coercing
 import graphql.schema.GraphQLAppliedDirective
 import graphql.schema.GraphQLCodeRegistry
@@ -2743,7 +2744,7 @@ input Gun {
                 .description(" custom directive 'example' description 1")
                 .definition(DirectiveDefinition.newDirectiveDefinition().comments(makeComments(" custom directive 'example' comment 1")).build()).build()
         def asteroidType = newScalar().name("Asteroid").description("desc")
-                .definition(ScalarTypeDefinition.newScalarTypeDefinition().comments(makeComments(" scalar Asteroid comment 1")).build())
+                .definition(ScalarTypeDefinition.newScalarTypeDefinition().name("Asteroid").comments(makeComments(" scalar Asteroid comment 1")).build())
                 .coercing(TestUtil.mockCoercing())
                 .build()
         def nodeType = newInterface().name("Node")
@@ -2754,11 +2755,11 @@ input Gun {
                 .field(newFieldDefinition().name("name").type(GraphQLString).build())
                 .build()
         def episodeType = newEnum().name("Episode")
-                .definition(newEnumTypeDefinition().comments(
+                .definition(newEnumTypeDefinition().name("Episode").comments(
                         makeComments(" enum Episode comment 1", " enum Episode comment 2")).build())
                 .values(List.of(
                         GraphQLEnumValueDefinition.newEnumValueDefinition().name("EMPIRE")
-                                .definition(EnumValueDefinition.newEnumValueDefinition().comments(makeComments(" enum value EMPIRE comment 1")).build()).build(),
+                                .definition(EnumValueDefinition.newEnumValueDefinition().name("EMPIRE").comments(makeComments(" enum value EMPIRE comment 1")).build()).build(),
                         GraphQLEnumValueDefinition.newEnumValueDefinition().name("JEDI").build(),
                         GraphQLEnumValueDefinition.newEnumValueDefinition().name("NEWHOPE").withDirective(exampleDirective).build()))
                 .build()
@@ -2792,11 +2793,11 @@ input Gun {
         def queryType = newObject().name("Query")
                 .definition(newObjectTypeDefinition().comments(makeComments(" type query comment 1", " type query comment 2")).build())
                 .field(newFieldDefinition().name("hero").type(characterType)
-                        .definition(FieldDefinition.newFieldDefinition().comments(makeComments(" query field 'hero' comment")).build())
+                        .definition(FieldDefinition.newFieldDefinition().name("hero").type(new TypeName("Character")).comments(makeComments(" query field 'hero' comment")).build())
                         .argument(newArgument().name("episode").type(episodeType).build())
                         .build())
                 .field(newFieldDefinition().name("humanoid").type(humanoidType)
-                        .definition(FieldDefinition.newFieldDefinition().comments(makeComments(" query field 'humanoid' comment")).build())
+                        .definition(FieldDefinition.newFieldDefinition().name("humanoid").type(new TypeName("Humanoid")).comments(makeComments(" query field 'humanoid' comment")).build())
                         .argument(newArgument().name("id").type(nonNull(GraphQLID)).build())
                         .build())
                 .build()
diff --git a/src/test/groovy/graphql/schema/somepackage/InterfaceInheritanceHolder.java b/src/test/groovy/graphql/schema/somepackage/InterfaceInheritanceHolder.java
new file mode 100644
index 0000000000..e5cd61bee0
--- /dev/null
+++ b/src/test/groovy/graphql/schema/somepackage/InterfaceInheritanceHolder.java
@@ -0,0 +1,138 @@
+package graphql.schema.somepackage;
+
+import graphql.schema.DataFetchingEnvironment;
+
+/**
+ * Test fixtures for interface-extends-interface method resolution.
+ * <p>
+ * Tests the recursive interface search in findMethodOnPublicInterfaces:
+ * a package-private class implements a package-private interface that extends
+ * a public interface. The method is only declared on the public grandparent,
+ * so the algorithm must recursively traverse through the package-private
+ * interface to find it.
+ * <p>
+ * Linear chain:
+ * <pre>
+ *   PublicBaseInterface (public)              — defines getBaseValue()
+ *        |
+ *   PackagePrivateMiddleInterface            — extends PublicBaseInterface (adds nothing new)
+ *        |
+ *   PackagePrivateChainImpl (package-private) — implements PackagePrivateMiddleInterface
+ * </pre>
+ * <p>
+ * Diamond pattern:
+ * <pre>
+ *        PublicBaseInterface (public)          — defines getBaseValue()
+ *             /          \
+ *  PackagePrivateBranchA   PackagePrivateBranchB  — each adds own method
+ *             \          /
+ *        DiamondImpl (package-private)
+ * </pre>
+ */
+public class InterfaceInheritanceHolder {
+
+    // --- Linear interface chain ---
+
+    public interface PublicBaseInterface {
+        String getBaseValue();
+    }
+
+    // Package-private interface extending a public interface — adds no new methods
+    interface PackagePrivateMiddleInterface extends PublicBaseInterface {
+    }
+
+    // Package-private class: only implements the package-private interface.
+    // getBaseValue() is declared on PublicBaseInterface — the recursive search
+    // must traverse PackagePrivateMiddleInterface -> PublicBaseInterface to find it.
+    static class PackagePrivateChainImpl implements PackagePrivateMiddleInterface {
+        @Override
+        public String getBaseValue() {
+            return "baseValue";
+        }
+    }
+
+    // --- Diamond pattern ---
+
+    // Two package-private interfaces both extending PublicBaseInterface
+    interface PackagePrivateBranchA extends PublicBaseInterface {
+        String getBranchAValue();
+    }
+
+    interface PackagePrivateBranchB extends PublicBaseInterface {
+        String getBranchBValue();
+    }
+
+    // Package-private class implementing both branches (diamond).
+    // getBaseValue() is only on PublicBaseInterface — must be found through either branch.
+    static class DiamondImpl implements PackagePrivateBranchA, PackagePrivateBranchB {
+        @Override
+        public String getBaseValue() {
+            return "diamondBaseValue";
+        }
+
+        @Override
+        public String getBranchAValue() {
+            return "branchAValue";
+        }
+
+        @Override
+        public String getBranchBValue() {
+            return "branchBValue";
+        }
+    }
+
+    // --- DFE interface: public interface with a method accepting DataFetchingEnvironment ---
+
+    public interface PublicDfeInterface {
+        String getDfeValue(DataFetchingEnvironment dfe);
+    }
+
+    // Package-private class implementing the public DFE interface.
+    // Exercises the dfeInUse path in findMethodOnPublicInterfaces.
+    static class PackagePrivateDfeImpl implements PublicDfeInterface {
+        @Override
+        public String getDfeValue(DataFetchingEnvironment dfe) {
+            return "dfeValue";
+        }
+    }
+
+    // --- Interface with multiple methods: one exists, one doesn't ---
+    // Used to exercise the NoSuchMethodException catch path in findMethodOnPublicInterfaces.
+
+    public interface PublicInterfaceWithoutTarget {
+        String getUnrelatedValue();
+    }
+
+    // Package-private class implementing an interface that does NOT have the fetched property.
+    // Also implements PublicBaseInterface which DOES have it.
+    // The search hits NoSuchMethodException on PublicInterfaceWithoutTarget, then finds it on PublicBaseInterface.
+    static class PackagePrivateMultiInterfaceImpl implements PublicInterfaceWithoutTarget, PublicBaseInterface {
+        @Override
+        public String getUnrelatedValue() {
+            return "unrelated";
+        }
+
+        @Override
+        public String getBaseValue() {
+            return "foundViaSecondInterface";
+        }
+    }
+
+    // --- Factory methods (public entry points for tests) ---
+
+    public static Object createChainImpl() {
+        return new PackagePrivateChainImpl();
+    }
+
+    public static Object createDiamondImpl() {
+        return new DiamondImpl();
+    }
+
+    public static Object createDfeImpl() {
+        return new PackagePrivateDfeImpl();
+    }
+
+    public static Object createMultiInterfaceImpl() {
+        return new PackagePrivateMultiInterfaceImpl();
+    }
+}
diff --git a/src/test/groovy/graphql/schema/transform/FieldVisibilitySchemaTransformationTest.groovy b/src/test/groovy/graphql/schema/transform/FieldVisibilitySchemaTransformationTest.groovy
index d5b05d6d89..0124e77b49 100644
--- a/src/test/groovy/graphql/schema/transform/FieldVisibilitySchemaTransformationTest.groovy
+++ b/src/test/groovy/graphql/schema/transform/FieldVisibilitySchemaTransformationTest.groovy
@@ -2010,4 +2010,73 @@ class FieldVisibilitySchemaTransformationTest extends Specification {
         assertSchemaIsValid(restrictedSchema)
     }
 
+    def "type is not deleted if remains a union member after its only private field path is removed"() {
+        given:
+        GraphQLSchema schema = TestUtil.schema("""
+
+        directive @private on FIELD_DEFINITION
+
+        type Query {
+            hello: String
+            createPizzaTopping(name: String!): PizzaToppingCreationPayload @private
+            toBeRemoved: PizzaToBeRemoved @private
+        }
+
+        union PizzaPolicy =
+            | PizzaTopping
+            | PizzaCrust
+            | PizzaDiscount
+            | PizzaAllergen
+
+        interface Payload {
+            success: Boolean!
+        }
+
+        type PizzaToppingCreationPayload implements Payload {
+            topping: PizzaTopping
+            success: Boolean!
+        }
+
+        type PizzaTopping {
+            id: ID
+            name: String
+        }
+
+        type PizzaCrust {
+            id: ID
+            name: String
+        }
+
+        type PizzaDiscount {
+            id: ID
+            percentage: Float
+        }
+
+        type PizzaAllergen {
+            id: ID
+            allergen: String
+        }
+        
+        type PizzaToBeRemoved {
+            id: ID
+        }
+        """)
+
+        when:
+        GraphQLSchema restrictedSchema = visibilitySchemaTransformation.apply(schema)
+
+        then: "the private field paths are removed"
+        (restrictedSchema.getType("Query") as GraphQLObjectType).getFieldDefinition("createPizzaTopping") == null
+        restrictedSchema.getType("PizzaToppingCreationPayload") == null
+
+        and: "PizzaTopping is still present because it is reachable as a union member of the public PizzaPolicy"
+        restrictedSchema.getType("PizzaTopping") != null
+
+        and: "Types with no reference at all (not a union member) is correctly removed"
+        restrictedSchema.getType("PizzaToBeRemoved") == null
+
+        and: "the resulting schema is valid - previously this would produce an invalid schema"
+        assertSchemaIsValid(restrictedSchema)
+    }
+
 }
diff --git a/src/test/groovy/graphql/util/AnonymizerTest.groovy b/src/test/groovy/graphql/util/AnonymizerTest.groovy
index ae6ed614a4..804ee88387 100644
--- a/src/test/groovy/graphql/util/AnonymizerTest.groovy
+++ b/src/test/groovy/graphql/util/AnonymizerTest.groovy
@@ -79,6 +79,27 @@ type Object2 {
 
     }
 
+    def "query with inline fragment without type condition"() {
+        given:
+        def schema = TestUtil.schema("""
+        type Query {
+            foo: Foo
+        }
+        type Foo {
+            bar1: String
+            bar2: ID
+        }
+        """)
+        def query = "{foo {... {bar1 bar2}}}"
+
+        when:
+        def result = Anonymizer.anonymizeSchemaAndQueries(schema, [query])
+        def newQuery = result.queries[0]
+
+        then:
+        newQuery == "{field1{...{field2 field3}}}"
+    }
+
     def "query with arguments"() {
         given:
         def schema = TestUtil.schema("""
diff --git a/src/test/groovy/graphql/validation/OverlappingFieldsCanBeMergedBenchmarkTest.groovy b/src/test/groovy/graphql/validation/OverlappingFieldsCanBeMergedBenchmarkTest.groovy
new file mode 100644
index 0000000000..af09868cc6
--- /dev/null
+++ b/src/test/groovy/graphql/validation/OverlappingFieldsCanBeMergedBenchmarkTest.groovy
@@ -0,0 +1,222 @@
+package graphql.validation
+
+import graphql.ExecutionResult
+import graphql.GraphQL
+import graphql.i18n.I18n
+import graphql.language.Document
+import graphql.parser.Parser
+import graphql.schema.GraphQLSchema
+import graphql.schema.idl.SchemaGenerator
+import spock.lang.Shared
+import spock.lang.Specification
+
+/**
+ * These tests mirror the JMH benchmarks in OverlappingFieldValidationPerformance
+ * and OverlappingFieldValidationBenchmark. They exercise the same validation paths
+ * and assert zero errors, ensuring the overlapping fields rule does not produce
+ * false positives (e.g. from null type handling).
+ */
+class OverlappingFieldsCanBeMergedBenchmarkTest extends Specification {
+
+    static String schemaSdl = " type Query { viewer: Viewer } interface Abstract { field: Abstract leaf: Int } interface Abstract1 { field: Abstract leaf: Int } interface Abstract2 { field: Abstract leaf: Int }" +
+            " type Concrete1 implements Abstract1{ field: Abstract leaf: Int}  " +
+            "type Concrete2 implements Abstract2{ field: Abstract leaf: Int} " +
+            "type Viewer { xingId: XingId } type XingId { firstName: String! lastName: String! }"
+
+    @Shared
+    GraphQLSchema schema
+
+    @Shared
+    GraphQLSchema schema2
+
+    @Shared
+    Document largeSchemaDocument
+
+    def setupSpec() {
+        String schemaString = loadResource("large-schema-4.graphqls")
+        String query = loadResource("large-schema-4-query.graphql")
+        schema = SchemaGenerator.createdMockedSchema(schemaString)
+        largeSchemaDocument = Parser.parse(query)
+        schema2 = SchemaGenerator.createdMockedSchema(schemaSdl)
+    }
+
+    private static String loadResource(String name) {
+        URL resource = OverlappingFieldsCanBeMergedBenchmarkTest.class.getClassLoader().getResource(name)
+        if (resource == null) {
+            throw new IllegalArgumentException("missing resource: " + name)
+        }
+        try (InputStream inputStream = resource.openStream()) {
+            return new String(inputStream.readAllBytes(), "UTF-8")
+        }
+    }
+
+    private List<ValidationError> validateQuery(GraphQLSchema schema, Document document) {
+        ValidationErrorCollector errorCollector = new ValidationErrorCollector()
+        I18n i18n = I18n.i18n(I18n.BundleType.Validation, Locale.ENGLISH)
+        ValidationContext validationContext = new ValidationContext(schema, document, i18n, QueryComplexityLimits.NONE)
+        OperationValidator operationValidator = new OperationValidator(validationContext, errorCollector,
+                { r -> r == OperationValidationRule.OVERLAPPING_FIELDS_CAN_BE_MERGED })
+        LanguageTraversal languageTraversal = new LanguageTraversal()
+        languageTraversal.traverse(document, operationValidator)
+        return errorCollector.getErrors()
+    }
+
+    // -- Large schema tests (mirrors OverlappingFieldValidationBenchmark) --
+
+    def "large schema query produces no validation errors"() {
+        when:
+        def errors = validateQuery(schema, largeSchemaDocument)
+
+        then:
+        errors.size() == 0
+    }
+
+    def "large schema query executes without errors"() {
+        when:
+        GraphQL graphQL = GraphQL.newGraphQL(schema).build()
+        def executionInput = graphql.ExecutionInput.newExecutionInput()
+                .query(loadResource("large-schema-4-query.graphql"))
+                .graphQLContext([(QueryComplexityLimits.KEY): QueryComplexityLimits.NONE])
+                .build()
+        ExecutionResult executionResult = graphQL.execute(executionInput)
+
+        then:
+        executionResult.errors.size() == 0
+    }
+
+    // -- Parameterized tests (mirrors OverlappingFieldValidationPerformance) --
+
+    def "overlapping fields with fragments produce no errors"() {
+        given:
+        Document doc = makeQueryWithFragments(100, true)
+
+        when:
+        def errors = validateQuery(schema2, doc)
+
+        then:
+        errors.size() == 0
+    }
+
+    def "overlapping fields without fragments produce no errors"() {
+        given:
+        Document doc = makeQueryWithoutFragments(100, true)
+
+        when:
+        def errors = validateQuery(schema2, doc)
+
+        then:
+        errors.size() == 0
+    }
+
+    def "non-overlapping fields with fragments produce no errors"() {
+        given:
+        Document doc = makeQueryWithFragments(100, false)
+
+        when:
+        def errors = validateQuery(schema2, doc)
+
+        then:
+        errors.size() == 0
+    }
+
+    def "non-overlapping fields without fragments produce no errors"() {
+        given:
+        Document doc = makeQueryWithoutFragments(100, false)
+
+        when:
+        def errors = validateQuery(schema2, doc)
+
+        then:
+        errors.size() == 0
+    }
+
+    def "repeated fields produce no errors"() {
+        given:
+        Document doc = makeRepeatedFieldsQuery(100)
+
+        when:
+        def errors = validateQuery(schema2, doc)
+
+        then:
+        errors.size() == 0
+    }
+
+    def "deep abstract concrete fields produce no errors"() {
+        given:
+        Document doc = makeDeepAbstractConcreteQuery(100)
+
+        when:
+        def errors = validateQuery(schema2, doc)
+
+        then:
+        errors.size() == 0
+    }
+
+    // -- Query builders (copied from OverlappingFieldValidationPerformance) --
+
+    private static Document makeQueryWithFragments(int size, boolean overlapping) {
+        StringBuilder b = new StringBuilder()
+
+        for (int i = 1; i <= size; i++) {
+            if (overlapping) {
+                b.append(" fragment mergeIdenticalFields" + i + " on Query {viewer { xingId { firstName lastName  }}}")
+            } else {
+                b.append("fragment mergeIdenticalFields" + i + " on Query {viewer" + i + " {  xingId" + i + " {  firstName" + i + "  lastName" + i + "  } }}")
+            }
+            b.append("\n\n")
+        }
+
+        b.append("query testQuery {")
+        for (int i = 1; i <= size; i++) {
+            b.append("...mergeIdenticalFields" + i + "\n")
+        }
+        b.append("}")
+        return Parser.parse(b.toString())
+    }
+
+    private static Document makeQueryWithoutFragments(int size, boolean overlapping) {
+        StringBuilder b = new StringBuilder()
+
+        b.append("query testQuery {")
+        for (int i = 1; i <= size; i++) {
+            if (overlapping) {
+                b.append(" viewer {   xingId {      firstName   } } ")
+            } else {
+                b.append(" viewer" + i + " {    xingId" + i + " {      firstName" + i + "    }  } ")
+            }
+            b.append("\n\n")
+        }
+        b.append("}")
+        return Parser.parse(b.toString())
+    }
+
+    private static Document makeRepeatedFieldsQuery(int size) {
+        StringBuilder b = new StringBuilder()
+        b.append(" query testQuery {  viewer {   xingId {")
+        b.append("firstName\n".repeat(Math.max(0, size)))
+        b.append("} } }")
+        return Parser.parse(b.toString())
+    }
+
+    private static Document makeDeepAbstractConcreteQuery(int depth) {
+        StringBuilder q = new StringBuilder()
+
+        q.append("fragment multiply on Whatever {   field {      " +
+                "... on Abstract1 { field { leaf } }      " +
+                "... on Abstract2 { field { leaf } }      " +
+                "... on Concrete1 { field { leaf } }      " +
+                "... on Concrete2 { field { leaf } }    } } " +
+                "query DeepAbstractConcrete { ")
+
+        for (int i = 1; i <= depth; i++) {
+            q.append("field { ...multiply ")
+        }
+
+        for (int i = 1; i <= depth; i++) {
+            q.append(" }")
+        }
+
+        q.append("\n}")
+        return Parser.parse(q.toString())
+    }
+}
diff --git a/src/test/groovy/graphql/validation/OverlappingFieldsCanBeMergedTest.groovy b/src/test/groovy/graphql/validation/OverlappingFieldsCanBeMergedTest.groovy
index 779ac756ea..c186f2c85d 100644
--- a/src/test/groovy/graphql/validation/OverlappingFieldsCanBeMergedTest.groovy
+++ b/src/test/groovy/graphql/validation/OverlappingFieldsCanBeMergedTest.groovy
@@ -6,6 +6,7 @@ import graphql.language.SourceLocation
 import graphql.parser.Parser
 import graphql.schema.GraphQLCodeRegistry
 import graphql.schema.GraphQLSchema
+import graphql.schema.idl.SchemaGenerator
 import graphql.validation.LanguageTraversal
 import graphql.validation.OperationValidationRule
 import graphql.validation.OperationValidator
@@ -967,6 +968,45 @@ class OverlappingFieldsCanBeMergedTest extends Specification {
         errorCollector.getErrors().size() == 0
     }
 
+    def "mixed null and non-null field types from unresolvable fragments should not conflict"() {
+        given:
+        // Regression test for commit 072165b which changed the null-handling in requireSameOutputTypeShape.
+        // This reproduces the benchmarkDeepAbstractConcrete JMH benchmark scenario: the fragment spreads
+        // on "Whatever" (which doesn't exist in the schema), so the outer "field" has null graphQLType.
+        // After mergeSubSelections, the inner field set contains both null-typed entries (from the
+        // unresolvable parent) and Abstract-typed entries (from the interface inline fragments).
+        // A null type means the parent was unresolvable, so we should skip the comparison rather than
+        // report a spurious conflict.
+        def schema = SchemaGenerator.createdMockedSchema('''
+            type Query { viewer: Viewer }
+            interface Abstract { field: Abstract leaf: Int }
+            interface Abstract1 { field: Abstract leaf: Int }
+            interface Abstract2 { field: Abstract leaf: Int }
+            type Concrete1 implements Abstract1 { field: Abstract leaf: Int }
+            type Concrete2 implements Abstract2 { field: Abstract leaf: Int }
+            type Viewer { xingId: XingId }
+            type XingId { firstName: String! lastName: String! }
+        ''')
+        def query = '''
+        fragment multiply on Whatever {
+            field {
+                ... on Abstract1 { field { leaf } }
+                ... on Abstract2 { field { leaf } }
+                ... on Concrete1 { field { leaf } }
+                ... on Concrete2 { field { leaf } }
+            }
+        }
+        query DeepAbstractConcrete {
+            field { ...multiply field { ...multiply } }
+        }
+        '''
+        when:
+        traverse(query, schema)
+
+        then:
+        errorCollector.getErrors().isEmpty()
+    }
+
     def "overlapping fields on lower level"() {
         given:
         def schema = schema('''
diff --git a/src/test/groovy/graphql/validation/QueryComplexityLimitsTest.groovy b/src/test/groovy/graphql/validation/QueryComplexityLimitsTest.groovy
new file mode 100644
index 0000000000..ece8cde7a4
--- /dev/null
+++ b/src/test/groovy/graphql/validation/QueryComplexityLimitsTest.groovy
@@ -0,0 +1,458 @@
+package graphql.validation
+
+import graphql.TestUtil
+import graphql.parser.Parser
+
+class QueryComplexityLimitsTest extends SpecValidationBase {
+
+    // ==================== ENO Parity Tests ====================
+    // These tests verify that our complexity tracking matches ExecutableNormalizedOperation (ENO)
+
+    def "ENO parity - depth and field count match ENO calculation"() {
+        // This test mirrors ExecutableNormalizedOperationFactoryTest."can capture depth and field count"
+        // ENO reports: depth=7, fieldCount=8
+        def schema = TestUtil.schema("""
+            type Query {
+                foo: Foo
+            }
+            type Foo {
+                stop : String
+                bar : Bar
+            }
+            type Bar {
+                stop : String
+                foo : Foo
+            }
+        """)
+
+        def query = "{ foo { bar { foo { bar { foo { stop bar { stop }}}}}}}"
+        def document = new Parser().parseDocument(query)
+
+        when: "we set limits that would fail if counts don't match ENO"
+        // ENO says fieldCount=8, so limit of 7 should fail
+        def limitsFieldCount = QueryComplexityLimits.newLimits()
+                .maxFieldsCount(7)
+                .build()
+        def errorsFieldCount = new Validator().validateDocument(schema, document, { r -> true }, Locale.ENGLISH, limitsFieldCount)
+
+        then: "field count of 8 exceeds limit of 7"
+        errorsFieldCount.size() == 1
+        errorsFieldCount[0].validationErrorType == ValidationErrorType.MaxQueryFieldsExceeded
+        errorsFieldCount[0].message.contains("8")
+
+        when: "we set limits that match ENO exactly"
+        def limitsExact = QueryComplexityLimits.newLimits()
+                .maxFieldsCount(8)
+                .maxDepth(7)
+                .build()
+        def errorsExact = new Validator().validateDocument(schema, document, { r -> true }, Locale.ENGLISH, limitsExact)
+
+        then: "validation passes with exact ENO counts"
+        errorsExact.isEmpty()
+
+        when: "depth limit of 6 should fail (ENO says depth=7)"
+        def limitsDepth = QueryComplexityLimits.newLimits()
+                .maxDepth(6)
+                .build()
+        def errorsDepth = new Validator().validateDocument(schema, document, { r -> true }, Locale.ENGLISH, limitsDepth)
+
+        then: "depth of 7 exceeds limit of 6"
+        errorsDepth.size() == 1
+        errorsDepth[0].validationErrorType == ValidationErrorType.MaxQueryDepthExceeded
+        errorsDepth[0].message.contains("7")
+    }
+
+    def "ENO parity - fragment spread counts fields at each site"() {
+        // This test mirrors ExecutableNormalizedOperationFactoryTest."query with fragment definition"
+        // Query: {foo { ...fooData moreFoos { ...fooData }}} fragment fooData on Foo { subFoo }
+        // ENO output: ['Query.foo', 'Foo.subFoo', 'Foo.moreFoos', 'Foo.subFoo']
+        // So subFoo is counted TWICE (once per spread) = 4 total fields
+        def schema = TestUtil.schema("""
+            type Query {
+                foo: Foo
+            }
+            type Foo {
+                subFoo: String
+                moreFoos: Foo
+            }
+        """)
+
+        def query = "{foo { ...fooData moreFoos { ...fooData }}} fragment fooData on Foo { subFoo }"
+        def document = new Parser().parseDocument(query)
+
+        when: "limit of 3 should fail (ENO counts 4 fields)"
+        def limits = QueryComplexityLimits.newLimits()
+                .maxFieldsCount(3)
+                .build()
+        def errors = new Validator().validateDocument(schema, document, { r -> true }, Locale.ENGLISH, limits)
+
+        then:
+        errors.size() == 1
+        errors[0].validationErrorType == ValidationErrorType.MaxQueryFieldsExceeded
+        errors[0].message.contains("4")  // foo + subFoo + moreFoos + subFoo = 4
+
+        when: "limit of 4 should pass"
+        def limitsPass = QueryComplexityLimits.newLimits()
+                .maxFieldsCount(4)
+                .build()
+        def errorsPass = new Validator().validateDocument(schema, document, { r -> true }, Locale.ENGLISH, limitsPass)
+
+        then:
+        errorsPass.isEmpty()
+    }
+
+    def "ENO parity - deeply nested fragments multiply field counts"() {
+        // Similar to ExecutableNormalizedOperationFactoryTest."factory has a default max node count"
+        // Each fragment spreads 3 times, creating exponential growth
+        def schema = TestUtil.schema("""
+            type Query {
+                foo: Foo
+            }
+            type Foo {
+                foo: Foo
+                name: String
+            }
+        """)
+
+        // F1 spreads F2 three times, F2 has just 'name'
+        // F1 contributes: 3 * F2's fields = 3 * 1 = 3 fields
+        // Query: foo + F1's fields = 1 + 3 = 4 fields
+        def query = """
+            { foo { ...F1 }}
+            fragment F1 on Foo {
+                a: foo { ...F2 }
+                b: foo { ...F2 }
+                c: foo { ...F2 }
+            }
+            fragment F2 on Foo {
+                name
+            }
+        """
+        def document = new Parser().parseDocument(query)
+
+        when:
+        // foo (1) + a:foo (1) + b:foo (1) + c:foo (1) + name*3 (3) = 7 fields
+        def limits = QueryComplexityLimits.newLimits()
+                .maxFieldsCount(6)
+                .build()
+        def errors = new Validator().validateDocument(schema, document, { r -> true }, Locale.ENGLISH, limits)
+
+        then:
+        errors.size() == 1
+        errors[0].validationErrorType == ValidationErrorType.MaxQueryFieldsExceeded
+        errors[0].message.contains("7")
+
+        when: "limit of 7 should pass"
+        def limitsPass = QueryComplexityLimits.newLimits()
+                .maxFieldsCount(7)
+                .build()
+        def errorsPass = new Validator().validateDocument(schema, document, { r -> true }, Locale.ENGLISH, limitsPass)
+
+        then:
+        errorsPass.isEmpty()
+    }
+
+    // ==================== Original Tests ====================
+
+    def "default limits are applied automatically"() {
+        expect:
+        QueryComplexityLimits.DEFAULT.getMaxDepth() == 100
+        QueryComplexityLimits.DEFAULT.getMaxFieldsCount() == 100_000
+        QueryComplexityLimits.getDefaultLimits() == QueryComplexityLimits.DEFAULT
+    }
+
+    def "default limits can be changed globally"() {
+        given:
+        def originalDefault = QueryComplexityLimits.getDefaultLimits()
+
+        when: "we set custom default limits"
+        def customLimits = QueryComplexityLimits.newLimits().maxDepth(5).maxFieldsCount(10).build()
+        QueryComplexityLimits.setDefaultLimits(customLimits)
+
+        then:
+        QueryComplexityLimits.getDefaultLimits() == customLimits
+
+        when: "we can disable limits globally with NONE"
+        QueryComplexityLimits.setDefaultLimits(QueryComplexityLimits.NONE)
+
+        then:
+        QueryComplexityLimits.getDefaultLimits() == QueryComplexityLimits.NONE
+
+        cleanup:
+        QueryComplexityLimits.setDefaultLimits(originalDefault)
+    }
+
+    def "simple queries pass with default limits"() {
+        def query = """
+            query deepQuery {
+                dog {
+                    name
+                    owner {
+                        name
+                    }
+                }
+            }
+        """
+        when:
+        def validationErrors = validate(query)
+
+        then:
+        validationErrors.isEmpty()
+    }
+
+    def "NONE disables limits entirely"() {
+        def schema = TestUtil.schema("""
+            type Query { a: A }
+            type A { b: B }
+            type B { c: C }
+            type C { d: String }
+        """)
+        // This query has depth 4, which exceeds default of 50? No, 4 < 50. Let me create a deeper one.
+        // Actually let's just verify NONE works by setting a very low custom limit first, then NONE
+        def query = "{ a { b { c { d }}}}"
+        def document = new Parser().parseDocument(query)
+
+        when: "using NONE, no limits are enforced"
+        def errors = new Validator().validateDocument(schema, document, { r -> true }, Locale.ENGLISH, QueryComplexityLimits.NONE)
+
+        then:
+        errors.isEmpty()
+    }
+
+    def "field count limit is enforced"() {
+        def query = """
+            query {
+                dog {
+                    name
+                    nickname
+                    barkVolume
+                }
+            }
+        """
+        when:
+        def limits = QueryComplexityLimits.newLimits()
+                .maxFieldsCount(3)
+                .build()
+        def document = new Parser().parseDocument(query)
+        def validationErrors = new Validator().validateDocument(
+                SpecValidationSchema.specValidationSchema, document, { r -> true }, Locale.ENGLISH, limits)
+
+        then:
+        validationErrors.size() == 1
+        validationErrors[0].validationErrorType == ValidationErrorType.MaxQueryFieldsExceeded
+        validationErrors[0].message.contains("4")  // actual
+        validationErrors[0].message.contains("3")  // limit
+    }
+
+    def "depth limit is enforced"() {
+        def query = """
+            query {
+                dog {
+                    owner {
+                        name
+                    }
+                }
+            }
+        """
+        when:
+        def limits = QueryComplexityLimits.newLimits()
+                .maxDepth(2)
+                .build()
+        def document = new Parser().parseDocument(query)
+        def validationErrors = new Validator().validateDocument(
+                SpecValidationSchema.specValidationSchema, document, { r -> true }, Locale.ENGLISH, limits)
+
+        then:
+        validationErrors.size() == 1
+        validationErrors[0].validationErrorType == ValidationErrorType.MaxQueryDepthExceeded
+        validationErrors[0].message.contains("3")  // actual depth
+        validationErrors[0].message.contains("2")  // limit
+    }
+
+    def "fragment fields are counted at each spread site"() {
+        // Fragment F has 2 fields (name, nickname)
+        // Query has: dog1, dog2, dog3 = 3 fields + 3 spreads * 2 fields = 9 total fields
+        def query = """
+            fragment F on Dog { name nickname }
+            query {
+                dog1: dog { ...F }
+                dog2: dog { ...F }
+                dog3: dog { ...F }
+            }
+        """
+        when:
+        def limits = QueryComplexityLimits.newLimits()
+                .maxFieldsCount(8)
+                .build()
+        def document = new Parser().parseDocument(query)
+        def validationErrors = new Validator().validateDocument(
+                SpecValidationSchema.specValidationSchema, document, { r -> true }, Locale.ENGLISH, limits)
+
+        then:
+        validationErrors.size() == 1
+        validationErrors[0].validationErrorType == ValidationErrorType.MaxQueryFieldsExceeded
+        validationErrors[0].message.contains("9")  // actual
+        validationErrors[0].message.contains("8")  // limit
+    }
+
+    def "fragment depth adds to current depth"() {
+        // Query depth: dog at depth 1, fragment adds 1 more (name) = max depth 2
+        def query = """
+            fragment F on Dog { name }
+            query {
+                dog { ...F }
+            }
+        """
+        when:
+        def limits = QueryComplexityLimits.newLimits()
+                .maxDepth(1)
+                .build()
+        def document = new Parser().parseDocument(query)
+        def validationErrors = new Validator().validateDocument(
+                SpecValidationSchema.specValidationSchema, document, { r -> true }, Locale.ENGLISH, limits)
+
+        then:
+        validationErrors.size() == 1
+        validationErrors[0].validationErrorType == ValidationErrorType.MaxQueryDepthExceeded
+    }
+
+    def "nested fragments are handled correctly"() {
+        // Fragment A spreads fragment B, each has 1 field
+        // Total: dog (1) + A's name (1) + B's nickname (1) = 3 fields
+        def query = """
+            fragment A on Dog { name ...B }
+            fragment B on Dog { nickname }
+            query {
+                dog { ...A }
+            }
+        """
+        when:
+        def limits = QueryComplexityLimits.newLimits()
+                .maxFieldsCount(2)
+                .build()
+        def document = new Parser().parseDocument(query)
+        def validationErrors = new Validator().validateDocument(
+                SpecValidationSchema.specValidationSchema, document, { r -> true }, Locale.ENGLISH, limits)
+
+        then:
+        validationErrors.size() == 1
+        validationErrors[0].validationErrorType == ValidationErrorType.MaxQueryFieldsExceeded
+    }
+
+    def "multiple operations each have separate limits"() {
+        // Each operation should be validated independently
+        def query = """
+            query First {
+                dog { name }
+            }
+            query Second {
+                dog { name nickname barkVolume }
+            }
+        """
+        when:
+        def limits = QueryComplexityLimits.newLimits()
+                .maxFieldsCount(3)
+                .build()
+        def document = new Parser().parseDocument(query)
+        def validationErrors = new Validator().validateDocument(
+                SpecValidationSchema.specValidationSchema, document, { r -> true }, Locale.ENGLISH, limits)
+
+        then:
+        // Second operation has 4 fields (dog + 3 scalar fields), which exceeds limit of 3
+        validationErrors.size() == 1
+        validationErrors[0].validationErrorType == ValidationErrorType.MaxQueryFieldsExceeded
+    }
+
+    def "inline fragments count their fields"() {
+        def query = """
+            query {
+                dog {
+                    ... on Dog {
+                        name
+                        nickname
+                    }
+                }
+            }
+        """
+        when:
+        def limits = QueryComplexityLimits.newLimits()
+                .maxFieldsCount(2)
+                .build()
+        def document = new Parser().parseDocument(query)
+        def validationErrors = new Validator().validateDocument(
+                SpecValidationSchema.specValidationSchema, document, { r -> true }, Locale.ENGLISH, limits)
+
+        then:
+        // dog (1) + name (1) + nickname (1) = 3 fields
+        validationErrors.size() == 1
+        validationErrors[0].validationErrorType == ValidationErrorType.MaxQueryFieldsExceeded
+    }
+
+    def "passes when within limits"() {
+        def query = """
+            query {
+                dog {
+                    name
+                    owner {
+                        name
+                    }
+                }
+            }
+        """
+        when:
+        def limits = QueryComplexityLimits.newLimits()
+                .maxFieldsCount(10)
+                .maxDepth(5)
+                .build()
+        def document = new Parser().parseDocument(query)
+        def validationErrors = new Validator().validateDocument(
+                SpecValidationSchema.specValidationSchema, document, { r -> true }, Locale.ENGLISH, limits)
+
+        then:
+        validationErrors.isEmpty()
+    }
+
+    def "QueryComplexityLimits.NONE has no limits"() {
+        expect:
+        QueryComplexityLimits.NONE.getMaxDepth() == Integer.MAX_VALUE
+        QueryComplexityLimits.NONE.getMaxFieldsCount() == Integer.MAX_VALUE
+    }
+
+    def "builder validates positive values"() {
+        when:
+        QueryComplexityLimits.newLimits().maxDepth(0).build()
+
+        then:
+        thrown(IllegalArgumentException)
+
+        when:
+        QueryComplexityLimits.newLimits().maxFieldsCount(-1).build()
+
+        then:
+        thrown(IllegalArgumentException)
+    }
+
+    def "cyclic fragments don't cause infinite loop in complexity calculation"() {
+        // This query has a cycle: A -> B -> A
+        // The validation should detect the cycle error, but complexity calculation shouldn't hang
+        def query = """
+            fragment A on Dog { ...B }
+            fragment B on Dog { ...A }
+            query {
+                dog { ...A }
+            }
+        """
+        when:
+        def limits = QueryComplexityLimits.newLimits()
+                .maxFieldsCount(100)
+                .maxDepth(100)
+                .build()
+        def document = new Parser().parseDocument(query)
+        def validationErrors = new Validator().validateDocument(
+                SpecValidationSchema.specValidationSchema, document, { r -> true }, Locale.ENGLISH, limits)
+
+        then:
+        // Should get fragment cycle error, not hang
+        validationErrors.any { it.validationErrorType == ValidationErrorType.FragmentCycle }
+    }
+}
diff --git a/src/test/groovy/graphql/validation/TraversalContextTest.groovy b/src/test/groovy/graphql/validation/TraversalContextTest.groovy
index 0afcbc1964..381ea6e118 100644
--- a/src/test/groovy/graphql/validation/TraversalContextTest.groovy
+++ b/src/test/groovy/graphql/validation/TraversalContextTest.groovy
@@ -128,7 +128,7 @@ class TraversalContextTest extends Specification {
 
     def "fragmentDefinition type condition saved as output type"() {
         given:
-        FragmentDefinition fragmentDefinition = FragmentDefinition.newFragmentDefinition().name("fragment").typeCondition(new TypeName(droidType.getName())).build()
+        FragmentDefinition fragmentDefinition = FragmentDefinition.newFragmentDefinition().name("fragment").typeCondition(new TypeName(droidType.getName())).selectionSet(SelectionSet.newSelectionSet().build()).build()
 
         when:
         traversalContext.enter(fragmentDefinition, [])
@@ -165,6 +165,7 @@ class TraversalContextTest extends Specification {
         FragmentDefinition fragmentDefinition = FragmentDefinition.newFragmentDefinition()
                 .name("fragment")
                 .typeCondition(new TypeName(inputHumanType.getName()))
+                .selectionSet(SelectionSet.newSelectionSet().build())
                 .build()
 
         when:
diff --git a/test-baseline.json b/test-baseline.json
new file mode 100644
index 0000000000..f8f91e408d
--- /dev/null
+++ b/test-baseline.json
@@ -0,0 +1,185809 @@
+{
+  "tests": {
+    "java11": {
+      "total": 5733,
+      "passed": 5677,
+      "failed": 0,
+      "errors": 0,
+      "skipped": 56
+    },
+    "java17": {
+      "total": 5733,
+      "passed": 5676,
+      "failed": 0,
+      "errors": 0,
+      "skipped": 57
+    },
+    "java21": {
+      "total": 5733,
+      "passed": 5676,
+      "failed": 0,
+      "errors": 0,
+      "skipped": 57
+    },
+    "java25": {
+      "total": 5733,
+      "passed": 5676,
+      "failed": 0,
+      "errors": 0,
+      "skipped": 57
+    },
+    "jcstress": {
+      "total": 32,
+      "passed": 32,
+      "failed": 0,
+      "errors": 0,
+      "skipped": 0
+    }
+  },
+  "coverage": {
+    "overall": {
+      "branch": {
+        "covered": 8418,
+        "missed": 1504
+      },
+      "line": {
+        "covered": 28903,
+        "missed": 3119
+      },
+      "method": {
+        "covered": 7730,
+        "missed": 1222
+      }
+    },
+    "classes": {
+      "graphql.language.OperationDefinition$Operation": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.ArrayValue$Builder": {
+        "line": {
+          "covered": 22,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/ArrayValue;)V",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/ArrayValue$Builder;",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "values",
+            "desc": "(Ljava/util/List;)Lgraphql/language/ArrayValue$Builder;",
+            "line": 134,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "value",
+            "desc": "(Lgraphql/language/Value;)Lgraphql/language/ArrayValue$Builder;",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/ArrayValue$Builder;",
+            "line": 144,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/ArrayValue$Builder;",
+            "line": 149,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/ArrayValue$Builder;",
+            "line": 155,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/ArrayValue$Builder;",
+            "line": 160,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/ArrayValue;",
+            "line": 165,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.FloatValue$Builder": {
+        "line": {
+          "covered": 18,
+          "missed": 10
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 5
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/FloatValue;)V",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/FloatValue$Builder;",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "value",
+            "desc": "(Ljava/math/BigDecimal;)Lgraphql/language/FloatValue$Builder;",
+            "line": 142,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "value",
+            "desc": "(D)Lgraphql/language/FloatValue$Builder;",
+            "line": 147,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "value",
+            "desc": "(J)Lgraphql/language/FloatValue$Builder;",
+            "line": 152,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/FloatValue$Builder;",
+            "line": 157,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/FloatValue$Builder;",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/FloatValue$Builder;",
+            "line": 167,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/FloatValue$Builder;",
+            "line": 172,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/FloatValue;",
+            "line": 178,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.UnionTypeExtensionDefinition$Builder": {
+        "line": {
+          "covered": 18,
+          "missed": 21
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 7
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/UnionTypeDefinition;)V",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 14
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/UnionTypeExtensionDefinition$Builder;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/UnionTypeExtensionDefinition$Builder;",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/UnionTypeExtensionDefinition$Builder;",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Lgraphql/language/Description;)Lgraphql/language/UnionTypeExtensionDefinition$Builder;",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "directives",
+            "desc": "(Ljava/util/List;)Lgraphql/language/UnionTypeExtensionDefinition$Builder;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directive",
+            "desc": "(Lgraphql/language/Directive;)Lgraphql/language/UnionTypeExtensionDefinition$Builder;",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "memberTypes",
+            "desc": "(Ljava/util/List;)Lgraphql/language/UnionTypeExtensionDefinition$Builder;",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "memberType",
+            "desc": "(Lgraphql/language/Type;)Lgraphql/language/UnionTypeExtensionDefinition$Builder;",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/UnionTypeExtensionDefinition$Builder;",
+            "line": 141,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/UnionTypeExtensionDefinition$Builder;",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/UnionTypeExtensionDefinition$Builder;",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/UnionTypeExtensionDefinition;",
+            "line": 157,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.PrettyAstPrinter$PrettyPrinterOptions$IndentType": {
+        "line": {
+          "covered": 5,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;ILjava/lang/String;)V",
+            "line": 431,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 426,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.NonNullType": {
+        "line": {
+          "covered": 18,
+          "missed": 7
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 3
+        },
+        "method": {
+          "covered": 11,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Type;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Type;)V",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getType",
+            "desc": "()Lgraphql/language/Type;",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/NonNullType;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/NonNullType;",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newNonNullType",
+            "desc": "()Lgraphql/language/NonNullType$Builder;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newNonNullType",
+            "desc": "(Lgraphql/language/Type;)Lgraphql/language/NonNullType$Builder;",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/NonNullType;",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/NonNullType$Builder;)V",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.InlineFragment$Builder": {
+        "line": {
+          "covered": 30,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 10,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 174,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/InlineFragment;)V",
+            "line": 174,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/InlineFragment$Builder;",
+            "line": 197,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/InlineFragment$Builder;",
+            "line": 202,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "typeCondition",
+            "desc": "(Lgraphql/language/TypeName;)Lgraphql/language/InlineFragment$Builder;",
+            "line": 207,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directives",
+            "desc": "(Ljava/util/List;)Lgraphql/language/InlineFragment$Builder;",
+            "line": 213,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directive",
+            "desc": "(Lgraphql/language/Directive;)Lgraphql/language/InlineFragment$Builder;",
+            "line": 218,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "selectionSet",
+            "desc": "(Lgraphql/language/SelectionSet;)Lgraphql/language/InlineFragment$Builder;",
+            "line": 224,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/InlineFragment$Builder;",
+            "line": 229,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/InlineFragment$Builder;",
+            "line": 234,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/InlineFragment$Builder;",
+            "line": 239,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/InlineFragment;",
+            "line": 245,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.AstNodeAdapter": {
+        "line": {
+          "covered": 4,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "getNamedChildren",
+            "desc": "(Lgraphql/language/Node;)Ljava/util/Map;",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/Node;Ljava/util/Map;)Lgraphql/language/Node;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "removeChild",
+            "desc": "(Lgraphql/language/Node;Lgraphql/util/NodeLocation;)Lgraphql/language/Node;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 18,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.TypeName$Builder": {
+        "line": {
+          "covered": 14,
+          "missed": 10
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/TypeName;)V",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 9
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/TypeName$Builder;",
+            "line": 128,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/TypeName$Builder;",
+            "line": 133,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/TypeName$Builder;",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/TypeName$Builder;",
+            "line": 143,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/TypeName$Builder;",
+            "line": 148,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/TypeName$Builder;",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/TypeName;",
+            "line": 158,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.ObjectTypeDefinition": {
+        "line": {
+          "covered": 46,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 2
+        },
+        "method": {
+          "covered": 18,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/List;Ljava/util/List;Ljava/util/List;Lgraphql/language/Description;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getImplements",
+            "desc": "()Ljava/util/List;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasDirective",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinitions",
+            "desc": "()Ljava/util/List;",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 109,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/ObjectTypeDefinition;",
+            "line": 118,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/ObjectTypeDefinition;",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 152,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newObjectTypeDefinition",
+            "desc": "()Lgraphql/language/ObjectTypeDefinition$Builder;",
+            "line": 166,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/ObjectTypeDefinition;",
+            "line": 170,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/ObjectTypeDefinition$Builder;)V",
+            "line": 118,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.VariableReference$Builder": {
+        "line": {
+          "covered": 19,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/VariableReference;)V",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/VariableReference$Builder;",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/VariableReference$Builder;",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/VariableReference$Builder;",
+            "line": 142,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/VariableReference$Builder;",
+            "line": 147,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/VariableReference$Builder;",
+            "line": 152,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/VariableReference$Builder;",
+            "line": 157,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/VariableReference;",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.OperationDefinition": {
+        "line": {
+          "covered": 44,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 5,
+          "missed": 5
+        },
+        "method": {
+          "covered": 16,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/OperationDefinition$Operation;Ljava/util/List;Ljava/util/List;Lgraphql/language/SelectionSet;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/OperationDefinition;",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOperation",
+            "desc": "()Lgraphql/language/OperationDefinition$Operation;",
+            "line": 97,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getVariableDefinitions",
+            "desc": "()Ljava/util/List;",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "hasDirective",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getSelectionSet",
+            "desc": "()Lgraphql/language/SelectionSet;",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 5
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/OperationDefinition;",
+            "line": 145,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 158,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 169,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newOperationDefinition",
+            "desc": "()Lgraphql/language/OperationDefinition$Builder;",
+            "line": 173,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/OperationDefinition;",
+            "line": 177,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/OperationDefinition$Builder;)V",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.AstTransformer": {
+        "line": {
+          "covered": 18,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Lgraphql/language/Node;Lgraphql/language/NodeVisitor;)Lgraphql/language/Node;",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Lgraphql/language/Node;Lgraphql/language/NodeVisitor;Ljava/util/Map;)Lgraphql/language/Node;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transformParallel",
+            "desc": "(Lgraphql/language/Node;Lgraphql/language/NodeVisitor;)Lgraphql/language/Node;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transformParallel",
+            "desc": "(Lgraphql/language/Node;Lgraphql/language/NodeVisitor;Ljava/util/concurrent/ForkJoinPool;)Lgraphql/language/Node;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNodeTraverserVisitor",
+            "desc": "(Lgraphql/language/NodeVisitor;)Lgraphql/util/TraverserVisitor;",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.NodeVisitorStub": {
+        "line": {
+          "covered": 43,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 43,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 13,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitArgument",
+            "desc": "(Lgraphql/language/Argument;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitArrayValue",
+            "desc": "(Lgraphql/language/ArrayValue;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 21,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitBooleanValue",
+            "desc": "(Lgraphql/language/BooleanValue;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitDirective",
+            "desc": "(Lgraphql/language/Directive;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitDirectiveDefinition",
+            "desc": "(Lgraphql/language/DirectiveDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitDirectiveLocation",
+            "desc": "(Lgraphql/language/DirectiveLocation;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitDocument",
+            "desc": "(Lgraphql/language/Document;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitEnumTypeDefinition",
+            "desc": "(Lgraphql/language/EnumTypeDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitEnumValue",
+            "desc": "(Lgraphql/language/EnumValue;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitEnumValueDefinition",
+            "desc": "(Lgraphql/language/EnumValueDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitField",
+            "desc": "(Lgraphql/language/Field;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitFieldDefinition",
+            "desc": "(Lgraphql/language/FieldDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitFloatValue",
+            "desc": "(Lgraphql/language/FloatValue;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitFragmentDefinition",
+            "desc": "(Lgraphql/language/FragmentDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitFragmentSpread",
+            "desc": "(Lgraphql/language/FragmentSpread;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitInlineFragment",
+            "desc": "(Lgraphql/language/InlineFragment;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitInputObjectTypeDefinition",
+            "desc": "(Lgraphql/language/InputObjectTypeDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitInputValueDefinition",
+            "desc": "(Lgraphql/language/InputValueDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitIntValue",
+            "desc": "(Lgraphql/language/IntValue;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 106,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitInterfaceTypeDefinition",
+            "desc": "(Lgraphql/language/InterfaceTypeDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitListType",
+            "desc": "(Lgraphql/language/ListType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitNonNullType",
+            "desc": "(Lgraphql/language/NonNullType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitNullValue",
+            "desc": "(Lgraphql/language/NullValue;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitObjectField",
+            "desc": "(Lgraphql/language/ObjectField;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitObjectTypeDefinition",
+            "desc": "(Lgraphql/language/ObjectTypeDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitObjectValue",
+            "desc": "(Lgraphql/language/ObjectValue;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 141,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitOperationDefinition",
+            "desc": "(Lgraphql/language/OperationDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitOperationTypeDefinition",
+            "desc": "(Lgraphql/language/OperationTypeDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitScalarTypeDefinition",
+            "desc": "(Lgraphql/language/ScalarTypeDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitSchemaDefinition",
+            "desc": "(Lgraphql/language/SchemaDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 161,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitSelectionSet",
+            "desc": "(Lgraphql/language/SelectionSet;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 166,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitStringValue",
+            "desc": "(Lgraphql/language/StringValue;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 171,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitTypeName",
+            "desc": "(Lgraphql/language/TypeName;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 176,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitUnionTypeDefinition",
+            "desc": "(Lgraphql/language/UnionTypeDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 181,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitVariableDefinition",
+            "desc": "(Lgraphql/language/VariableDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 186,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitVariableReference",
+            "desc": "(Lgraphql/language/VariableReference;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 191,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitValue",
+            "desc": "(Lgraphql/language/Value;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 196,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitDefinition",
+            "desc": "(Lgraphql/language/Definition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 200,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitTypeDefinition",
+            "desc": "(Lgraphql/language/TypeDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 204,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitSelection",
+            "desc": "(Lgraphql/language/Selection;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 208,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitType",
+            "desc": "(Lgraphql/language/Type;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 212,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitNode",
+            "desc": "(Lgraphql/language/Node;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 216,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.AbstractNode": {
+        "line": {
+          "covered": 18,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 1
+        },
+        "method": {
+          "covered": 8,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;)V",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSourceLocation",
+            "desc": "()Lgraphql/language/SourceLocation;",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getComments",
+            "desc": "()Ljava/util/List;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getIgnoredChars",
+            "desc": "()Lgraphql/language/IgnoredChars;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAdditionalData",
+            "desc": "()Ljava/util/Map;",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "(Lgraphql/language/Node;)Lgraphql/language/Node;",
+            "line": 63,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "(Ljava/util/List;)Ljava/util/List;",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$deepCopy$0",
+            "desc": "(Lgraphql/language/Node;)Lgraphql/language/Node;",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.SelectionSet$Builder": {
+        "line": {
+          "covered": 26,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 9,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/SelectionSet;)V",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "selections",
+            "desc": "(Ljava/util/Collection;)Lgraphql/language/SelectionSet$Builder;",
+            "line": 144,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "selection",
+            "desc": "(Lgraphql/language/Selection;)Lgraphql/language/SelectionSet$Builder;",
+            "line": 149,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/SelectionSet$Builder;",
+            "line": 154,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/SelectionSet$Builder;",
+            "line": 159,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/SelectionSet$Builder;",
+            "line": 164,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/SelectionSet$Builder;",
+            "line": 169,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/SelectionSet$Builder;",
+            "line": 174,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/SelectionSet;",
+            "line": 179,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.Field$Builder": {
+        "line": {
+          "covered": 37,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 12,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 243,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Field;)V",
+            "line": 243,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/Field$Builder;",
+            "line": 269,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/Field$Builder;",
+            "line": 274,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/Field$Builder;",
+            "line": 279,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "alias",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/Field$Builder;",
+            "line": 284,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "arguments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/Field$Builder;",
+            "line": 289,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directives",
+            "desc": "(Ljava/util/List;)Lgraphql/language/Field$Builder;",
+            "line": 295,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directive",
+            "desc": "(Lgraphql/language/Directive;)Lgraphql/language/Field$Builder;",
+            "line": 300,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "selectionSet",
+            "desc": "(Lgraphql/language/SelectionSet;)Lgraphql/language/Field$Builder;",
+            "line": 305,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/Field$Builder;",
+            "line": 310,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/Field$Builder;",
+            "line": 315,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/Field$Builder;",
+            "line": 320,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/Field;",
+            "line": 326,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.SelectionSet": {
+        "line": {
+          "covered": 26,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 3
+        },
+        "method": {
+          "covered": 16,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Collection;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Collection;)V",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSelections",
+            "desc": "()Ljava/util/List;",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSelectionsOfType",
+            "desc": "(Ljava/lang/Class;)Ljava/util/List;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/SelectionSet;",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/SelectionSet;",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newSelectionSet",
+            "desc": "()Lgraphql/language/SelectionSet$Builder;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newSelectionSet",
+            "desc": "(Ljava/util/Collection;)Lgraphql/language/SelectionSet$Builder;",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/SelectionSet;",
+            "line": 119,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/SelectionSet$Builder;)V",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getSelectionsOfType$0",
+            "desc": "(Ljava/lang/Class;Lgraphql/language/Selection;)Z",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.NullValue$Builder": {
+        "line": {
+          "covered": 10,
+          "missed": 12
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/NullValue;)V",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 9
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/NullValue$Builder;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/NullValue$Builder;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/NullValue$Builder;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/NullValue$Builder;",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/NullValue$Builder;",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/NullValue;",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.NodeUtil$DirectivesHolder": {
+        "line": {
+          "covered": 10,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "of",
+            "desc": "(Ljava/util/List;)Lgraphql/language/NodeUtil$DirectivesHolder;",
+            "line": 118,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;)V",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Lcom/google/common/collect/ImmutableList;",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Lcom/google/common/collect/ImmutableMap;",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "(Ljava/lang/String;)Lcom/google/common/collect/ImmutableList;",
+            "line": 135,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasDirective",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 144,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.EnumValueDefinition": {
+        "line": {
+          "covered": 24,
+          "missed": 8
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 3
+        },
+        "method": {
+          "covered": 12,
+          "missed": 6
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/List;Lgraphql/language/Description;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/List;)V",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "hasDirective",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/EnumValueDefinition;",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/EnumValueDefinition;",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newEnumValueDefinition",
+            "desc": "()Lgraphql/language/EnumValueDefinition$Builder;",
+            "line": 142,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/EnumValueDefinition;",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/EnumValueDefinition$Builder;)V",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.NonNullType$Builder": {
+        "line": {
+          "covered": 17,
+          "missed": 14
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 1
+        },
+        "method": {
+          "covered": 7,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/NonNullType;)V",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 10
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/NonNullType$Builder;",
+            "line": 134,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "type",
+            "desc": "(Lgraphql/language/ListType;)Lgraphql/language/NonNullType$Builder;",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "type",
+            "desc": "(Lgraphql/language/TypeName;)Lgraphql/language/NonNullType$Builder;",
+            "line": 144,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "type",
+            "desc": "(Lgraphql/language/Type;)Lgraphql/language/NonNullType$Builder;",
+            "line": 149,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/NonNullType$Builder;",
+            "line": 157,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/NonNullType$Builder;",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/NonNullType$Builder;",
+            "line": 167,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/NonNullType$Builder;",
+            "line": 172,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/NonNullType;",
+            "line": 178,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.ScalarTypeExtensionDefinition": {
+        "line": {
+          "covered": 3,
+          "missed": 9
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 5
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/List;Lgraphql/language/Description;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/ScalarTypeExtensionDefinition;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "newScalarTypeExtensionDefinition",
+            "desc": "()Lgraphql/language/ScalarTypeExtensionDefinition$Builder;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/ScalarTypeExtensionDefinition;",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "transformExtension",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/ScalarTypeExtensionDefinition;",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/ScalarTypeExtensionDefinition$Builder;)V",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.ObjectValue": {
+        "line": {
+          "covered": 21,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 3
+        },
+        "method": {
+          "covered": 12,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;)V",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getObjectFields",
+            "desc": "()Ljava/util/List;",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/ObjectValue;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/ObjectValue;",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newObjectValue",
+            "desc": "()Lgraphql/language/ObjectValue$Builder;",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/ObjectValue;",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/ObjectValue$Builder;)V",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.EnumTypeExtensionDefinition$Builder": {
+        "line": {
+          "covered": 28,
+          "missed": 10
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 8,
+          "missed": 5
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/EnumTypeExtensionDefinition;)V",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/EnumTypeExtensionDefinition$Builder;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/EnumTypeExtensionDefinition$Builder;",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/EnumTypeExtensionDefinition$Builder;",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Lgraphql/language/Description;)Lgraphql/language/EnumTypeExtensionDefinition$Builder;",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "enumValueDefinitions",
+            "desc": "(Ljava/util/List;)Lgraphql/language/EnumTypeExtensionDefinition$Builder;",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directives",
+            "desc": "(Ljava/util/List;)Lgraphql/language/EnumTypeExtensionDefinition$Builder;",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directive",
+            "desc": "(Lgraphql/language/Directive;)Lgraphql/language/EnumTypeExtensionDefinition$Builder;",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/EnumTypeExtensionDefinition$Builder;",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/EnumTypeExtensionDefinition$Builder;",
+            "line": 141,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/EnumTypeExtensionDefinition$Builder;",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/EnumTypeExtensionDefinition;",
+            "line": 152,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.OperationDefinition$Builder": {
+        "line": {
+          "covered": 38,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 12,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 185,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/OperationDefinition;)V",
+            "line": 185,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/OperationDefinition$Builder;",
+            "line": 211,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/OperationDefinition$Builder;",
+            "line": 216,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/OperationDefinition$Builder;",
+            "line": 221,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "operation",
+            "desc": "(Lgraphql/language/OperationDefinition$Operation;)Lgraphql/language/OperationDefinition$Builder;",
+            "line": 226,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "variableDefinitions",
+            "desc": "(Ljava/util/List;)Lgraphql/language/OperationDefinition$Builder;",
+            "line": 231,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "variableDefinition",
+            "desc": "(Lgraphql/language/VariableDefinition;)Lgraphql/language/OperationDefinition$Builder;",
+            "line": 236,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "directives",
+            "desc": "(Ljava/util/List;)Lgraphql/language/OperationDefinition$Builder;",
+            "line": 242,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directive",
+            "desc": "(Lgraphql/language/Directive;)Lgraphql/language/OperationDefinition$Builder;",
+            "line": 247,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "selectionSet",
+            "desc": "(Lgraphql/language/SelectionSet;)Lgraphql/language/OperationDefinition$Builder;",
+            "line": 252,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/OperationDefinition$Builder;",
+            "line": 257,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/OperationDefinition$Builder;",
+            "line": 262,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/OperationDefinition$Builder;",
+            "line": 267,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/OperationDefinition;",
+            "line": 272,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.FragmentSpread": {
+        "line": {
+          "covered": 23,
+          "missed": 8
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 3
+        },
+        "method": {
+          "covered": 12,
+          "missed": 6
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/List;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "hasDirective",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 97,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/FragmentSpread;",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/FragmentSpread;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 124,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newFragmentSpread",
+            "desc": "()Lgraphql/language/FragmentSpread$Builder;",
+            "line": 128,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newFragmentSpread",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/FragmentSpread$Builder;",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/FragmentSpread;",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/FragmentSpread$Builder;)V",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.TypeName": {
+        "line": {
+          "covered": 17,
+          "missed": 7
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 3
+        },
+        "method": {
+          "covered": 11,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/TypeName;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/TypeName;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newTypeName",
+            "desc": "()Lgraphql/language/TypeName$Builder;",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newTypeName",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/TypeName$Builder;",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/TypeName;",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.Document$Builder": {
+        "line": {
+          "covered": 26,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 9,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 161,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Document;)V",
+            "line": 161,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "definitions",
+            "desc": "(Ljava/util/List;)Lgraphql/language/Document$Builder;",
+            "line": 179,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "definition",
+            "desc": "(Lgraphql/language/Definition;)Lgraphql/language/Document$Builder;",
+            "line": 184,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/Document$Builder;",
+            "line": 189,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/Document$Builder;",
+            "line": 194,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/Document$Builder;",
+            "line": 199,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/Document$Builder;",
+            "line": 204,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/Document$Builder;",
+            "line": 209,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/Document;",
+            "line": 215,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.SourceLocation": {
+        "line": {
+          "covered": 18,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 5,
+          "missed": 3
+        },
+        "method": {
+          "covered": 8,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(II)V",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(IILjava/lang/String;)V",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLine",
+            "desc": "()I",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getColumn",
+            "desc": "()I",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSourceName",
+            "desc": "()Ljava/lang/String;",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocation",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;)Lgraphql/language/SourceLocation;",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.OperationTypeDefinition$Builder": {
+        "line": {
+          "covered": 16,
+          "missed": 12
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/OperationTypeDefinition;)V",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 11
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/OperationTypeDefinition$Builder;",
+            "line": 147,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/OperationTypeDefinition$Builder;",
+            "line": 152,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/OperationTypeDefinition$Builder;",
+            "line": 157,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "typeName",
+            "desc": "(Lgraphql/language/TypeName;)Lgraphql/language/OperationTypeDefinition$Builder;",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/OperationTypeDefinition$Builder;",
+            "line": 167,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/OperationTypeDefinition$Builder;",
+            "line": 172,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/OperationTypeDefinition$Builder;",
+            "line": 177,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/OperationTypeDefinition;",
+            "line": 183,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.InputObjectTypeExtensionDefinition": {
+        "line": {
+          "covered": 9,
+          "missed": 12
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/List;Ljava/util/List;Lgraphql/language/Description;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/InputObjectTypeExtensionDefinition;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 8
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "newInputObjectTypeExtensionDefinition",
+            "desc": "()Lgraphql/language/InputObjectTypeExtensionDefinition$Builder;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/InputObjectTypeExtensionDefinition;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transformExtension",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/InputObjectTypeExtensionDefinition;",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/InputObjectTypeExtensionDefinition$Builder;)V",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.ScalarTypeExtensionDefinition$Builder": {
+        "line": {
+          "covered": 15,
+          "missed": 19
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 6
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/ScalarTypeDefinition;)V",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 13
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/ScalarTypeExtensionDefinition$Builder;",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/ScalarTypeExtensionDefinition$Builder;",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/ScalarTypeExtensionDefinition$Builder;",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Lgraphql/language/Description;)Lgraphql/language/ScalarTypeExtensionDefinition$Builder;",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "directives",
+            "desc": "(Ljava/util/List;)Lgraphql/language/ScalarTypeExtensionDefinition$Builder;",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directive",
+            "desc": "(Lgraphql/language/Directive;)Lgraphql/language/ScalarTypeExtensionDefinition$Builder;",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/ScalarTypeExtensionDefinition$Builder;",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/ScalarTypeExtensionDefinition$Builder;",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/ScalarTypeExtensionDefinition$Builder;",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/ScalarTypeExtensionDefinition;",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.AstTransformer$1": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/AstTransformer;Lgraphql/language/NodeVisitor;)V",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enter",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.AstTransformer$2": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/AstTransformer;Lgraphql/language/NodeVisitor;)V",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enter",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "leave",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.FloatValue": {
+        "line": {
+          "covered": 20,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 3
+        },
+        "method": {
+          "covered": 12,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/math/BigDecimal;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/math/BigDecimal;)V",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getValue",
+            "desc": "()Ljava/math/BigDecimal;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/FloatValue;",
+            "line": 63,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/FloatValue;",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/FloatValue;",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(D)Lgraphql/language/FloatValue;",
+            "line": 106,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newFloatValue",
+            "desc": "()Lgraphql/language/FloatValue$Builder;",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newFloatValue",
+            "desc": "(Ljava/math/BigDecimal;)Lgraphql/language/FloatValue$Builder;",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.IgnoredChar$IgnoredCharKind": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.FieldDefinition": {
+        "line": {
+          "covered": 44,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 3
+        },
+        "method": {
+          "covered": 16,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Type;Ljava/util/List;Ljava/util/List;Lgraphql/language/Description;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Type;)V",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getType",
+            "desc": "()Lgraphql/language/Type;",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInputValueDefinitions",
+            "desc": "()Ljava/util/List;",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "hasDirective",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/FieldDefinition;",
+            "line": 113,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 122,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/FieldDefinition;",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 149,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 159,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newFieldDefinition",
+            "desc": "()Lgraphql/language/FieldDefinition$Builder;",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/FieldDefinition;",
+            "line": 167,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/FieldDefinition$Builder;)V",
+            "line": 113,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.InputObjectTypeDefinition$Builder": {
+        "line": {
+          "covered": 35,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 12,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 154,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/InputObjectTypeDefinition;)V",
+            "line": 154,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/InputObjectTypeDefinition$Builder;",
+            "line": 177,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/InputObjectTypeDefinition$Builder;",
+            "line": 182,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/InputObjectTypeDefinition$Builder;",
+            "line": 187,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Lgraphql/language/Description;)Lgraphql/language/InputObjectTypeDefinition$Builder;",
+            "line": 192,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directives",
+            "desc": "(Ljava/util/List;)Lgraphql/language/InputObjectTypeDefinition$Builder;",
+            "line": 198,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directive",
+            "desc": "(Lgraphql/language/Directive;)Lgraphql/language/InputObjectTypeDefinition$Builder;",
+            "line": 203,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inputValueDefinitions",
+            "desc": "(Ljava/util/List;)Lgraphql/language/InputObjectTypeDefinition$Builder;",
+            "line": 208,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inputValueDefinition",
+            "desc": "(Lgraphql/language/InputValueDefinition;)Lgraphql/language/InputObjectTypeDefinition$Builder;",
+            "line": 213,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/InputObjectTypeDefinition$Builder;",
+            "line": 218,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/InputObjectTypeDefinition$Builder;",
+            "line": 223,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/InputObjectTypeDefinition$Builder;",
+            "line": 228,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/InputObjectTypeDefinition;",
+            "line": 234,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.SchemaDefinition": {
+        "line": {
+          "covered": 21,
+          "missed": 10
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 2
+        },
+        "method": {
+          "covered": 10,
+          "missed": 7
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;Ljava/util/List;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;Lgraphql/language/Description;)V",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "hasDirective",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getOperationTypeDefinitions",
+            "desc": "()Ljava/util/List;",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDescription",
+            "desc": "()Lgraphql/language/Description;",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/SchemaDefinition;",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/SchemaDefinition;",
+            "line": 106,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/SchemaDefinition;",
+            "line": 124,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newSchemaDefinition",
+            "desc": "()Lgraphql/language/SchemaDefinition$Builder;",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/SchemaDefinition$Builder;)V",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.ObjectTypeDefinition$Builder": {
+        "line": {
+          "covered": 42,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 14,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 178,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/ObjectTypeDefinition;)V",
+            "line": 178,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/ObjectTypeDefinition$Builder;",
+            "line": 203,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/ObjectTypeDefinition$Builder;",
+            "line": 208,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/ObjectTypeDefinition$Builder;",
+            "line": 213,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Lgraphql/language/Description;)Lgraphql/language/ObjectTypeDefinition$Builder;",
+            "line": 218,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "implementz",
+            "desc": "(Ljava/util/List;)Lgraphql/language/ObjectTypeDefinition$Builder;",
+            "line": 223,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "implementz",
+            "desc": "(Lgraphql/language/Type;)Lgraphql/language/ObjectTypeDefinition$Builder;",
+            "line": 228,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directives",
+            "desc": "(Ljava/util/List;)Lgraphql/language/ObjectTypeDefinition$Builder;",
+            "line": 234,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directive",
+            "desc": "(Lgraphql/language/Directive;)Lgraphql/language/ObjectTypeDefinition$Builder;",
+            "line": 239,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldDefinitions",
+            "desc": "(Ljava/util/List;)Lgraphql/language/ObjectTypeDefinition$Builder;",
+            "line": 244,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldDefinition",
+            "desc": "(Lgraphql/language/FieldDefinition;)Lgraphql/language/ObjectTypeDefinition$Builder;",
+            "line": 249,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/ObjectTypeDefinition$Builder;",
+            "line": 254,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/ObjectTypeDefinition$Builder;",
+            "line": 259,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/ObjectTypeDefinition$Builder;",
+            "line": 264,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/ObjectTypeDefinition;",
+            "line": 269,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.IgnoredChars": {
+        "line": {
+          "covered": 7,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;Ljava/util/List;)V",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLeft",
+            "desc": "()Ljava/util/List;",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getRight",
+            "desc": "()Ljava/util/List;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.NullValue": {
+        "line": {
+          "covered": 8,
+          "missed": 11
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 6
+        },
+        "method": {
+          "covered": 7,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "()Lgraphql/language/NullValue;",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/NullValue;",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 5
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 6
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/NullValue;",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newNullValue",
+            "desc": "()Lgraphql/language/NullValue$Builder;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/NullValue;",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.FragmentDefinition$Builder": {
+        "line": {
+          "covered": 29,
+          "missed": 8
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 9,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 173,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/FragmentDefinition;)V",
+            "line": 173,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/FragmentDefinition$Builder;",
+            "line": 198,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/FragmentDefinition$Builder;",
+            "line": 203,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/FragmentDefinition$Builder;",
+            "line": 208,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "typeCondition",
+            "desc": "(Lgraphql/language/TypeName;)Lgraphql/language/FragmentDefinition$Builder;",
+            "line": 213,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directives",
+            "desc": "(Ljava/util/List;)Lgraphql/language/FragmentDefinition$Builder;",
+            "line": 219,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directive",
+            "desc": "(Lgraphql/language/Directive;)Lgraphql/language/FragmentDefinition$Builder;",
+            "line": 224,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "selectionSet",
+            "desc": "(Lgraphql/language/SelectionSet;)Lgraphql/language/FragmentDefinition$Builder;",
+            "line": 229,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/FragmentDefinition$Builder;",
+            "line": 234,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/FragmentDefinition$Builder;",
+            "line": 239,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/FragmentDefinition$Builder;",
+            "line": 244,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/FragmentDefinition;",
+            "line": 250,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.TypeKind": {
+        "line": {
+          "covered": 14,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 11,
+          "missed": 1
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "getTypeKind",
+            "desc": "(Lgraphql/language/TypeDefinition;)Lgraphql/language/TypeKind;",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 11,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 9,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.BooleanValue$Builder": {
+        "line": {
+          "covered": 19,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/BooleanValue;)V",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/BooleanValue$Builder;",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "value",
+            "desc": "(Z)Lgraphql/language/BooleanValue$Builder;",
+            "line": 142,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/BooleanValue$Builder;",
+            "line": 147,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/BooleanValue$Builder;",
+            "line": 152,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/BooleanValue$Builder;",
+            "line": 157,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/BooleanValue$Builder;",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/BooleanValue;",
+            "line": 168,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.IgnoredChar": {
+        "line": {
+          "covered": 5,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/IgnoredChar$IgnoredCharKind;Lgraphql/language/SourceLocation;)V",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getValue",
+            "desc": "()Ljava/lang/String;",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getKind",
+            "desc": "()Lgraphql/language/IgnoredChar$IgnoredCharKind;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getSourceLocation",
+            "desc": "()Lgraphql/language/SourceLocation;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.Description": {
+        "line": {
+          "covered": 7,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/SourceLocation;Z)V",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getContent",
+            "desc": "()Ljava/lang/String;",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSourceLocation",
+            "desc": "()Lgraphql/language/SourceLocation;",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isMultiLine",
+            "desc": "()Z",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.Argument$Builder": {
+        "line": {
+          "covered": 22,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Argument;)V",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/Argument$Builder;",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/Argument$Builder;",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "value",
+            "desc": "(Lgraphql/language/Value;)Lgraphql/language/Argument$Builder;",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/Argument$Builder;",
+            "line": 161,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/Argument$Builder;",
+            "line": 166,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/Argument$Builder;",
+            "line": 171,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/Argument$Builder;",
+            "line": 176,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/Argument;",
+            "line": 181,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.SchemaDefinition$Builder": {
+        "line": {
+          "covered": 33,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 11,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 135,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/SchemaDefinition;)V",
+            "line": 135,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Lgraphql/language/Description;)Lgraphql/language/SchemaDefinition$Builder;",
+            "line": 157,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/SchemaDefinition$Builder;",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/SchemaDefinition$Builder;",
+            "line": 167,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directives",
+            "desc": "(Ljava/util/List;)Lgraphql/language/SchemaDefinition$Builder;",
+            "line": 172,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directive",
+            "desc": "(Lgraphql/language/Directive;)Lgraphql/language/SchemaDefinition$Builder;",
+            "line": 177,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "operationTypeDefinitions",
+            "desc": "(Ljava/util/List;)Lgraphql/language/SchemaDefinition$Builder;",
+            "line": 182,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "operationTypeDefinition",
+            "desc": "(Lgraphql/language/OperationTypeDefinition;)Lgraphql/language/SchemaDefinition$Builder;",
+            "line": 187,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/SchemaDefinition$Builder;",
+            "line": 192,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/SchemaDefinition$Builder;",
+            "line": 197,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/SchemaDefinition$Builder;",
+            "line": 202,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/SchemaDefinition;",
+            "line": 207,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.EnumValue": {
+        "line": {
+          "covered": 17,
+          "missed": 8
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 3
+        },
+        "method": {
+          "covered": 11,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/EnumValue;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/EnumValue;",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/EnumValue;",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newEnumValue",
+            "desc": "()Lgraphql/language/EnumValue$Builder;",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newEnumValue",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/EnumValue$Builder;",
+            "line": 109,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/EnumValue;",
+            "line": 113,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.NodeChildrenContainer": {
+        "line": {
+          "covered": 11,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 1
+        },
+        "method": {
+          "covered": 6,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Map;)V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildOrNull",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/Node;",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/Map;",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newNodeChildrenContainer",
+            "desc": "()Lgraphql/language/NodeChildrenContainer$Builder;",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newNodeChildrenContainer",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/NodeChildrenContainer$Builder;",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newNodeChildrenContainer",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/NodeChildrenContainer$Builder;",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/NodeChildrenContainer;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isEmpty",
+            "desc": "()Z",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.FragmentSpread$Builder": {
+        "line": {
+          "covered": 23,
+          "missed": 8
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 145,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/FragmentSpread;)V",
+            "line": 145,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/FragmentSpread$Builder;",
+            "line": 164,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/FragmentSpread$Builder;",
+            "line": 169,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/FragmentSpread$Builder;",
+            "line": 174,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directives",
+            "desc": "(Ljava/util/List;)Lgraphql/language/FragmentSpread$Builder;",
+            "line": 180,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directive",
+            "desc": "(Lgraphql/language/Directive;)Lgraphql/language/FragmentSpread$Builder;",
+            "line": 185,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/FragmentSpread$Builder;",
+            "line": 191,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/FragmentSpread$Builder;",
+            "line": 196,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/FragmentSpread$Builder;",
+            "line": 201,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/FragmentSpread;",
+            "line": 206,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.ObjectField": {
+        "line": {
+          "covered": 24,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 3
+        },
+        "method": {
+          "covered": 13,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Value;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Value;)V",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getValue",
+            "desc": "()Lgraphql/language/Value;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/ObjectField;",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/ObjectField;",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newObjectField",
+            "desc": "()Lgraphql/language/ObjectField$Builder;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/ObjectField;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/ObjectField$Builder;)V",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.InterfaceTypeDefinition": {
+        "line": {
+          "covered": 38,
+          "missed": 11
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 2
+        },
+        "method": {
+          "covered": 16,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/List;Ljava/util/List;Ljava/util/List;Lgraphql/language/Description;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getImplements",
+            "desc": "()Ljava/util/List;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinitions",
+            "desc": "()Ljava/util/List;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "hasDirective",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 97,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/InterfaceTypeDefinition;",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/InterfaceTypeDefinition;",
+            "line": 143,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 8
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 166,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newInterfaceTypeDefinition",
+            "desc": "()Lgraphql/language/InterfaceTypeDefinition$Builder;",
+            "line": 171,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/InterfaceTypeDefinition;",
+            "line": 175,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/InterfaceTypeDefinition$Builder;)V",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.NodeUtil": {
+        "line": {
+          "covered": 35,
+          "missed": 7
+        },
+        "branch": {
+          "covered": 23,
+          "missed": 3
+        },
+        "method": {
+          "covered": 5,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "findNodeByName",
+            "desc": "(Ljava/util/List;Ljava/lang/String;)Lgraphql/language/NamedNode;",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "allDirectivesByName",
+            "desc": "(Ljava/util/List;)Ljava/util/Map;",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "nodeByName",
+            "desc": "(Ljava/util/List;)Ljava/util/Map;",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFragmentsByName",
+            "desc": "(Lgraphql/language/Document;)Ljava/util/Map;",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOperation",
+            "desc": "(Lgraphql/language/Document;Ljava/lang/String;)Lgraphql/language/NodeUtil$GetOperationResult;",
+            "line": 63,
+            "counters": {
+              "line": {
+                "covered": 21,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 15,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertNewChildrenAreEmpty",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)V",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "removeChild",
+            "desc": "(Lgraphql/language/Node;Lgraphql/util/NodeLocation;)Lgraphql/language/Node;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$removeChild$0",
+            "desc": "(Lgraphql/util/NodeLocation;Lgraphql/language/NodeChildrenContainer$Builder;)V",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.EnumTypeDefinition": {
+        "line": {
+          "covered": 29,
+          "missed": 14
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 3
+        },
+        "method": {
+          "covered": 13,
+          "missed": 5
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/List;Ljava/util/List;Lgraphql/language/Description;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getEnumValueDefinitions",
+            "desc": "()Ljava/util/List;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "hasDirective",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 97,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/EnumTypeDefinition;",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 113,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/EnumTypeDefinition;",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 7
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 148,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newEnumTypeDefinition",
+            "desc": "()Lgraphql/language/EnumTypeDefinition$Builder;",
+            "line": 152,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/EnumTypeDefinition;",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/EnumTypeDefinition$Builder;)V",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.UnionTypeExtensionDefinition": {
+        "line": {
+          "covered": 3,
+          "missed": 17
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 5
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/List;Ljava/util/List;Lgraphql/language/Description;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/UnionTypeExtensionDefinition;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 7
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "newUnionTypeExtensionDefinition",
+            "desc": "()Lgraphql/language/UnionTypeExtensionDefinition$Builder;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/UnionTypeExtensionDefinition;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "transformExtension",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/UnionTypeExtensionDefinition;",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/UnionTypeExtensionDefinition$Builder;)V",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.UnionTypeDefinition": {
+        "line": {
+          "covered": 27,
+          "missed": 15
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 2
+        },
+        "method": {
+          "covered": 13,
+          "missed": 6
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/List;Ljava/util/List;Lgraphql/language/Description;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/List;)V",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "hasDirective",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getMemberTypes",
+            "desc": "()Ljava/util/List;",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/UnionTypeDefinition;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 119,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/UnionTypeDefinition;",
+            "line": 133,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 7
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 145,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 154,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newUnionTypeDefinition",
+            "desc": "()Lgraphql/language/UnionTypeDefinition$Builder;",
+            "line": 158,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/UnionTypeDefinition;",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/UnionTypeDefinition$Builder;)V",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.AstSorter": {
+        "line": {
+          "covered": 65,
+          "missed": 10
+        },
+        "branch": {
+          "covered": 44,
+          "missed": 10
+        },
+        "method": {
+          "covered": 14,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sort",
+            "desc": "(Lgraphql/language/Node;)Lgraphql/language/Node;",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comparingTypes",
+            "desc": "()Ljava/util/Comparator;",
+            "line": 235,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comparingSelections",
+            "desc": "()Ljava/util/Comparator;",
+            "line": 239,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comparingDefinitions",
+            "desc": "()Ljava/util/Comparator;",
+            "line": 268,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sortSelectionSet",
+            "desc": "(Lgraphql/language/SelectionSet;)Lgraphql/language/SelectionSet;",
+            "line": 335,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sort",
+            "desc": "(Ljava/util/List;Ljava/util/Comparator;)Ljava/util/List;",
+            "line": 343,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comparing",
+            "desc": "(Ljava/util/function/Function;)Ljava/util/Comparator;",
+            "line": 350,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$sortSelectionSet$0",
+            "desc": "(Ljava/util/List;Lgraphql/language/SelectionSet$Builder;)V",
+            "line": 339,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$comparingDefinitions$1",
+            "desc": "(Lgraphql/language/Definition;)Ljava/lang/Integer;",
+            "line": 285,
+            "counters": {
+              "line": {
+                "covered": 23,
+                "missed": 7
+              },
+              "branch": {
+                "covered": 21,
+                "missed": 7
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$comparingDefinitions$0",
+            "desc": "(Lgraphql/language/Definition;)Ljava/lang/String;",
+            "line": 269,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 9,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$comparingSelections$1",
+            "desc": "(Lgraphql/language/Selection;)Ljava/lang/Integer;",
+            "line": 253,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$comparingSelections$0",
+            "desc": "(Lgraphql/language/Selection;)Ljava/lang/String;",
+            "line": 240,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$comparingTypes$0",
+            "desc": "(Lgraphql/language/Type;)Ljava/lang/String;",
+            "line": 235,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.SchemaExtensionDefinition": {
+        "line": {
+          "covered": 6,
+          "missed": 8
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;Ljava/util/List;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/SchemaExtensionDefinition;",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/SchemaExtensionDefinition;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "transformExtension",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/SchemaExtensionDefinition;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newSchemaExtensionDefinition",
+            "desc": "()Lgraphql/language/SchemaExtensionDefinition$Builder;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/SchemaExtensionDefinition$Builder;)V",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.VariableReference": {
+        "line": {
+          "covered": 19,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 3
+        },
+        "method": {
+          "covered": 11,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/VariableReference;",
+            "line": 63,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/VariableReference;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/VariableReference;",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newVariableReference",
+            "desc": "()Lgraphql/language/VariableReference$Builder;",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/VariableReference;",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.NodeParentTree": {
+        "line": {
+          "covered": 23,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 6,
+          "missed": 0
+        },
+        "method": {
+          "covered": 8,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Deque;)V",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkPath",
+            "desc": "(Ljava/util/Deque;)Lcom/google/common/collect/ImmutableList;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNode",
+            "desc": "()Lgraphql/language/Node;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParentInfo",
+            "desc": "()Ljava/util/Optional;",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPath",
+            "desc": "()Ljava/util/List;",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toList",
+            "desc": "()Ljava/util/List;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$mkPath$1",
+            "desc": "(Lgraphql/language/Node;)Ljava/lang/String;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$mkPath$0",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.ObjectValue$Builder": {
+        "line": {
+          "covered": 21,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/ObjectValue;)V",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/ObjectValue$Builder;",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "objectFields",
+            "desc": "(Ljava/util/List;)Lgraphql/language/ObjectValue$Builder;",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "objectField",
+            "desc": "(Lgraphql/language/ObjectField;)Lgraphql/language/ObjectValue$Builder;",
+            "line": 141,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/ObjectValue$Builder;",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/ObjectValue$Builder;",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/ObjectValue$Builder;",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/ObjectValue$Builder;",
+            "line": 161,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/ObjectValue;",
+            "line": 166,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.StringValue$Builder": {
+        "line": {
+          "covered": 19,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 118,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/StringValue;)V",
+            "line": 118,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/StringValue$Builder;",
+            "line": 135,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "value",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/StringValue$Builder;",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/StringValue$Builder;",
+            "line": 145,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/StringValue$Builder;",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/StringValue$Builder;",
+            "line": 155,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/StringValue$Builder;",
+            "line": 160,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/StringValue;",
+            "line": 166,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.ArrayValue": {
+        "line": {
+          "covered": 23,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 3
+        },
+        "method": {
+          "covered": 13,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;)V",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newArrayValue",
+            "desc": "()Lgraphql/language/ArrayValue$Builder;",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getValues",
+            "desc": "()Ljava/util/List;",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/ArrayValue;",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/ArrayValue;",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/ArrayValue;",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/ArrayValue$Builder;)V",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.ObjectTypeExtensionDefinition$Builder": {
+        "line": {
+          "covered": 40,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 13,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/ObjectTypeDefinition;)V",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/ObjectTypeExtensionDefinition$Builder;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/ObjectTypeExtensionDefinition$Builder;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/ObjectTypeExtensionDefinition$Builder;",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Lgraphql/language/Description;)Lgraphql/language/ObjectTypeExtensionDefinition$Builder;",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "implementz",
+            "desc": "(Ljava/util/List;)Lgraphql/language/ObjectTypeExtensionDefinition$Builder;",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "implementz",
+            "desc": "(Lgraphql/language/Type;)Lgraphql/language/ObjectTypeExtensionDefinition$Builder;",
+            "line": 141,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directives",
+            "desc": "(Ljava/util/List;)Lgraphql/language/ObjectTypeExtensionDefinition$Builder;",
+            "line": 147,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directive",
+            "desc": "(Lgraphql/language/Directive;)Lgraphql/language/ObjectTypeExtensionDefinition$Builder;",
+            "line": 152,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldDefinitions",
+            "desc": "(Ljava/util/List;)Lgraphql/language/ObjectTypeExtensionDefinition$Builder;",
+            "line": 157,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldDefinition",
+            "desc": "(Lgraphql/language/FieldDefinition;)Lgraphql/language/ObjectTypeExtensionDefinition$Builder;",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/ObjectTypeExtensionDefinition$Builder;",
+            "line": 167,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/ObjectTypeExtensionDefinition$Builder;",
+            "line": 172,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/ObjectTypeExtensionDefinition$Builder;",
+            "line": 177,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/ObjectTypeExtensionDefinition;",
+            "line": 182,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.ScalarTypeDefinition": {
+        "line": {
+          "covered": 23,
+          "missed": 7
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 3
+        },
+        "method": {
+          "covered": 12,
+          "missed": 5
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/List;Lgraphql/language/Description;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "hasDirective",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/ScalarTypeDefinition;",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/ScalarTypeDefinition;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newScalarTypeDefinition",
+            "desc": "()Lgraphql/language/ScalarTypeDefinition$Builder;",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/ScalarTypeDefinition;",
+            "line": 133,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/ScalarTypeDefinition$Builder;)V",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.InputObjectTypeDefinition": {
+        "line": {
+          "covered": 27,
+          "missed": 11
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 3
+        },
+        "method": {
+          "covered": 14,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/List;Ljava/util/List;Lgraphql/language/Description;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "hasDirective",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getInputValueDefinitions",
+            "desc": "()Ljava/util/List;",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/InputObjectTypeDefinition;",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/InputObjectTypeDefinition;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 7
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 128,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newInputObjectDefinition",
+            "desc": "()Lgraphql/language/InputObjectTypeDefinition$Builder;",
+            "line": 142,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/InputObjectTypeDefinition;",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/InputObjectTypeDefinition$Builder;)V",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.EnumTypeDefinition$Builder": {
+        "line": {
+          "covered": 36,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 12,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 164,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/EnumTypeDefinition;)V",
+            "line": 164,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/EnumTypeDefinition$Builder;",
+            "line": 187,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/EnumTypeDefinition$Builder;",
+            "line": 192,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/EnumTypeDefinition$Builder;",
+            "line": 197,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Lgraphql/language/Description;)Lgraphql/language/EnumTypeDefinition$Builder;",
+            "line": 202,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enumValueDefinitions",
+            "desc": "(Ljava/util/List;)Lgraphql/language/EnumTypeDefinition$Builder;",
+            "line": 207,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enumValueDefinition",
+            "desc": "(Lgraphql/language/EnumValueDefinition;)Lgraphql/language/EnumTypeDefinition$Builder;",
+            "line": 212,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directives",
+            "desc": "(Ljava/util/List;)Lgraphql/language/EnumTypeDefinition$Builder;",
+            "line": 218,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directive",
+            "desc": "(Lgraphql/language/Directive;)Lgraphql/language/EnumTypeDefinition$Builder;",
+            "line": 223,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/EnumTypeDefinition$Builder;",
+            "line": 228,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/EnumTypeDefinition$Builder;",
+            "line": 233,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/EnumTypeDefinition$Builder;",
+            "line": 238,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/EnumTypeDefinition;",
+            "line": 244,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.Comment": {
+        "line": {
+          "covered": 5,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/SourceLocation;)V",
+            "line": 18,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getContent",
+            "desc": "()Ljava/lang/String;",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSourceLocation",
+            "desc": "()Lgraphql/language/SourceLocation;",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.InterfaceTypeExtensionDefinition": {
+        "line": {
+          "covered": 9,
+          "missed": 13
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/List;Ljava/util/List;Ljava/util/List;Lgraphql/language/Description;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/InterfaceTypeExtensionDefinition;",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 9
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "newInterfaceTypeExtensionDefinition",
+            "desc": "()Lgraphql/language/InterfaceTypeExtensionDefinition$Builder;",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/InterfaceTypeExtensionDefinition;",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transformExtension",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/InterfaceTypeExtensionDefinition;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/InterfaceTypeExtensionDefinition$Builder;)V",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.DirectiveDefinition$Builder": {
+        "line": {
+          "covered": 40,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 13,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 164,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/DirectiveDefinition;)V",
+            "line": 164,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/DirectiveDefinition$Builder;",
+            "line": 189,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/DirectiveDefinition$Builder;",
+            "line": 194,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/DirectiveDefinition$Builder;",
+            "line": 199,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "repeatable",
+            "desc": "(Z)Lgraphql/language/DirectiveDefinition$Builder;",
+            "line": 204,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Lgraphql/language/Description;)Lgraphql/language/DirectiveDefinition$Builder;",
+            "line": 209,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inputValueDefinitions",
+            "desc": "(Ljava/util/List;)Lgraphql/language/DirectiveDefinition$Builder;",
+            "line": 214,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inputValueDefinition",
+            "desc": "(Lgraphql/language/InputValueDefinition;)Lgraphql/language/DirectiveDefinition$Builder;",
+            "line": 219,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directiveLocations",
+            "desc": "(Ljava/util/List;)Lgraphql/language/DirectiveDefinition$Builder;",
+            "line": 225,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directiveLocation",
+            "desc": "(Lgraphql/language/DirectiveLocation;)Lgraphql/language/DirectiveDefinition$Builder;",
+            "line": 230,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/DirectiveDefinition$Builder;",
+            "line": 235,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/DirectiveDefinition$Builder;",
+            "line": 240,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/DirectiveDefinition$Builder;",
+            "line": 245,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/DirectiveDefinition;",
+            "line": 251,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.EnumTypeExtensionDefinition": {
+        "line": {
+          "covered": 9,
+          "missed": 11
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/List;Ljava/util/List;Lgraphql/language/Description;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/EnumTypeExtensionDefinition;",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 7
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "newEnumTypeExtensionDefinition",
+            "desc": "()Lgraphql/language/EnumTypeExtensionDefinition$Builder;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/EnumTypeExtensionDefinition;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transformExtension",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/EnumTypeExtensionDefinition;",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/EnumTypeExtensionDefinition$Builder;)V",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.InterfaceTypeExtensionDefinition$Builder": {
+        "line": {
+          "covered": 34,
+          "missed": 12
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 10,
+          "missed": 6
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/InterfaceTypeExtensionDefinition;)V",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/InterfaceTypeExtensionDefinition$Builder;",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/InterfaceTypeExtensionDefinition$Builder;",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/InterfaceTypeExtensionDefinition$Builder;",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Lgraphql/language/Description;)Lgraphql/language/InterfaceTypeExtensionDefinition$Builder;",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "implementz",
+            "desc": "(Ljava/util/List;)Lgraphql/language/InterfaceTypeExtensionDefinition$Builder;",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "implementz",
+            "desc": "(Lgraphql/language/Type;)Lgraphql/language/InterfaceTypeExtensionDefinition$Builder;",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "definitions",
+            "desc": "(Ljava/util/List;)Lgraphql/language/InterfaceTypeExtensionDefinition$Builder;",
+            "line": 135,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "definition",
+            "desc": "(Lgraphql/language/FieldDefinition;)Lgraphql/language/InterfaceTypeExtensionDefinition$Builder;",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "directives",
+            "desc": "(Ljava/util/List;)Lgraphql/language/InterfaceTypeExtensionDefinition$Builder;",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directive",
+            "desc": "(Lgraphql/language/Directive;)Lgraphql/language/InterfaceTypeExtensionDefinition$Builder;",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/InterfaceTypeExtensionDefinition$Builder;",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/InterfaceTypeExtensionDefinition$Builder;",
+            "line": 161,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/InterfaceTypeExtensionDefinition$Builder;",
+            "line": 166,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/InterfaceTypeExtensionDefinition;",
+            "line": 172,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.InterfaceTypeDefinition$Builder": {
+        "line": {
+          "covered": 42,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 14,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 183,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/InterfaceTypeDefinition;)V",
+            "line": 183,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/InterfaceTypeDefinition$Builder;",
+            "line": 210,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/InterfaceTypeDefinition$Builder;",
+            "line": 215,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/InterfaceTypeDefinition$Builder;",
+            "line": 220,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Lgraphql/language/Description;)Lgraphql/language/InterfaceTypeDefinition$Builder;",
+            "line": 225,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "implementz",
+            "desc": "(Ljava/util/List;)Lgraphql/language/InterfaceTypeDefinition$Builder;",
+            "line": 230,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "implementz",
+            "desc": "(Lgraphql/language/Type;)Lgraphql/language/InterfaceTypeDefinition$Builder;",
+            "line": 235,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "definitions",
+            "desc": "(Ljava/util/List;)Lgraphql/language/InterfaceTypeDefinition$Builder;",
+            "line": 241,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "definition",
+            "desc": "(Lgraphql/language/FieldDefinition;)Lgraphql/language/InterfaceTypeDefinition$Builder;",
+            "line": 246,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directives",
+            "desc": "(Ljava/util/List;)Lgraphql/language/InterfaceTypeDefinition$Builder;",
+            "line": 252,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directive",
+            "desc": "(Lgraphql/language/Directive;)Lgraphql/language/InterfaceTypeDefinition$Builder;",
+            "line": 257,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/InterfaceTypeDefinition$Builder;",
+            "line": 262,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/InterfaceTypeDefinition$Builder;",
+            "line": 267,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/InterfaceTypeDefinition$Builder;",
+            "line": 272,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/InterfaceTypeDefinition;",
+            "line": 278,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.NodeTraverser": {
+        "line": {
+          "covered": 21,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 10,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Map;Ljava/util/function/Function;)V",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "depthFirst",
+            "desc": "(Lgraphql/language/NodeVisitor;Lgraphql/language/Node;)Ljava/lang/Object;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "depthFirst",
+            "desc": "(Lgraphql/language/NodeVisitor;Ljava/util/Collection;)Ljava/lang/Object;",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "preOrder",
+            "desc": "(Lgraphql/language/NodeVisitor;Lgraphql/language/Node;)Ljava/lang/Object;",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "preOrder",
+            "desc": "(Lgraphql/language/NodeVisitor;Ljava/util/Collection;)Ljava/lang/Object;",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "postOrder",
+            "desc": "(Lgraphql/language/NodeVisitor;Lgraphql/language/Node;)Ljava/lang/Object;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "postOrder",
+            "desc": "(Lgraphql/language/NodeVisitor;Ljava/util/Collection;)Ljava/lang/Object;",
+            "line": 133,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "doTraverse",
+            "desc": "(Ljava/util/Collection;Lgraphql/util/TraverserVisitor;)Ljava/lang/Object;",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "oneVisitWithResult",
+            "desc": "(Lgraphql/language/Node;Lgraphql/language/NodeVisitor;)Ljava/lang/Object;",
+            "line": 157,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.VariableDefinition$Builder": {
+        "line": {
+          "covered": 31,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 10,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 204,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/VariableDefinition;)V",
+            "line": 204,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/VariableDefinition$Builder;",
+            "line": 226,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/VariableDefinition$Builder;",
+            "line": 231,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/VariableDefinition$Builder;",
+            "line": 236,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "type",
+            "desc": "(Lgraphql/language/Type;)Lgraphql/language/VariableDefinition$Builder;",
+            "line": 241,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "defaultValue",
+            "desc": "(Lgraphql/language/Value;)Lgraphql/language/VariableDefinition$Builder;",
+            "line": 246,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directives",
+            "desc": "(Ljava/util/List;)Lgraphql/language/VariableDefinition$Builder;",
+            "line": 252,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directive",
+            "desc": "(Lgraphql/language/Directive;)Lgraphql/language/VariableDefinition$Builder;",
+            "line": 257,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/VariableDefinition$Builder;",
+            "line": 262,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/VariableDefinition$Builder;",
+            "line": 267,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/VariableDefinition$Builder;",
+            "line": 272,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/VariableDefinition;",
+            "line": 277,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.FieldDefinition$Builder": {
+        "line": {
+          "covered": 39,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 13,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 176,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/FieldDefinition;)V",
+            "line": 176,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/FieldDefinition$Builder;",
+            "line": 201,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/FieldDefinition$Builder;",
+            "line": 206,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/FieldDefinition$Builder;",
+            "line": 211,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "type",
+            "desc": "(Lgraphql/language/Type;)Lgraphql/language/FieldDefinition$Builder;",
+            "line": 216,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Lgraphql/language/Description;)Lgraphql/language/FieldDefinition$Builder;",
+            "line": 221,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inputValueDefinitions",
+            "desc": "(Ljava/util/List;)Lgraphql/language/FieldDefinition$Builder;",
+            "line": 226,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inputValueDefinition",
+            "desc": "(Lgraphql/language/InputValueDefinition;)Lgraphql/language/FieldDefinition$Builder;",
+            "line": 231,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directives",
+            "desc": "(Ljava/util/List;)Lgraphql/language/FieldDefinition$Builder;",
+            "line": 238,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directive",
+            "desc": "(Lgraphql/language/Directive;)Lgraphql/language/FieldDefinition$Builder;",
+            "line": 243,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/FieldDefinition$Builder;",
+            "line": 248,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/FieldDefinition$Builder;",
+            "line": 253,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/FieldDefinition$Builder;",
+            "line": 258,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/FieldDefinition;",
+            "line": 264,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.AstSignature$1": {
+        "line": {
+          "covered": 15,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 17,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/AstSignature;ZLjava/util/Map;Ljava/util/concurrent/atomic/AtomicInteger;)V",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitIntValue",
+            "desc": "(Lgraphql/language/IntValue;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitFloatValue",
+            "desc": "(Lgraphql/language/FloatValue;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitStringValue",
+            "desc": "(Lgraphql/language/StringValue;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitBooleanValue",
+            "desc": "(Lgraphql/language/BooleanValue;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitArrayValue",
+            "desc": "(Lgraphql/language/ArrayValue;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitObjectValue",
+            "desc": "(Lgraphql/language/ObjectValue;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 106,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitVariableReference",
+            "desc": "(Lgraphql/language/VariableReference;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitVariableDefinition",
+            "desc": "(Lgraphql/language/VariableDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitVariableDefinition$0",
+            "desc": "(Ljava/lang/String;Lgraphql/language/VariableDefinition$Builder;)V",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitVariableReference$0",
+            "desc": "(Ljava/lang/String;Lgraphql/language/VariableReference$Builder;)V",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitObjectValue$0",
+            "desc": "(Lgraphql/language/ObjectValue$Builder;)V",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitArrayValue$0",
+            "desc": "(Lgraphql/language/ArrayValue$Builder;)V",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitBooleanValue$0",
+            "desc": "(Lgraphql/language/BooleanValue$Builder;)V",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitStringValue$0",
+            "desc": "(Lgraphql/language/StringValue$Builder;)V",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitFloatValue$0",
+            "desc": "(Lgraphql/language/FloatValue$Builder;)V",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitIntValue$0",
+            "desc": "(Lgraphql/language/IntValue$Builder;)V",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.AstSignature$2": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/AstSignature;)V",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitField",
+            "desc": "(Lgraphql/language/Field;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitField$0",
+            "desc": "(Lgraphql/language/Field$Builder;)V",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.AstSignature$3": {
+        "line": {
+          "covered": 10,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/AstSignature;Ljava/lang/String;)V",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitDocument",
+            "desc": "(Lgraphql/language/Document;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 154,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitDocument$1",
+            "desc": "(Ljava/util/List;Lgraphql/language/Document$Builder;)V",
+            "line": 165,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitDocument$0",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Definition;)Z",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.PrettyAstPrinter": {
+        "line": {
+          "covered": 199,
+          "missed": 10
+        },
+        "branch": {
+          "covered": 54,
+          "missed": 12
+        },
+        "method": {
+          "covered": 52,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/parser/NodeToRuleCapturingParser$ParserContext;)V",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/parser/NodeToRuleCapturingParser$ParserContext;Lgraphql/language/PrettyAstPrinter$PrettyPrinterOptions;)V",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 21,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "print",
+            "desc": "(Lgraphql/language/Node;)Ljava/lang/String;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "print",
+            "desc": "(Ljava/lang/String;Lgraphql/language/PrettyAstPrinter$PrettyPrinterOptions;)Ljava/lang/String;",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "document",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directiveDefinition",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enumTypeDefinition",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enumValueDefinition",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldDefinition",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "type",
+            "desc": "(Lgraphql/language/Type;)Ljava/lang/String;",
+            "line": 149,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inputObjectTypeDefinition",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inputValueDefinition",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 174,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "implementingTypeDefinition",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 189,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "scalarTypeDefinition",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 202,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unionTypeDefinition",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 212,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "node",
+            "desc": "(Lgraphql/language/Node;Ljava/lang/Class;)Ljava/lang/String;",
+            "line": 226,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEmpty",
+            "desc": "(Ljava/util/List;)Z",
+            "line": 246,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEmpty",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 250,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "nvl",
+            "desc": "(Ljava/util/List;)Ljava/util/List;",
+            "line": 254,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "outset",
+            "desc": "(Lgraphql/language/Node;)Ljava/lang/String;",
+            "line": 259,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Lgraphql/language/Node;)Ljava/lang/String;",
+            "line": 266,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 5
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comment",
+            "desc": "(Lgraphql/language/Comment;)Ljava/lang/String;",
+            "line": 281,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Ljava/lang/String;",
+            "line": 285,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;Ljava/lang/String;)Ljava/lang/String;",
+            "line": 289,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
+            "line": 293,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directives",
+            "desc": "(Ljava/util/List;)Ljava/lang/String;",
+            "line": 304,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "join",
+            "desc": "(Ljava/util/List;Ljava/lang/String;)Ljava/lang/String;",
+            "line": 308,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "join",
+            "desc": "(Ljava/util/List;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
+            "line": 312,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "node",
+            "desc": "(Lgraphql/language/Node;)Ljava/lang/String;",
+            "line": 322,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "spaced",
+            "desc": "([Ljava/lang/String;)Ljava/lang/String;",
+            "line": 326,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "prepend",
+            "desc": "(Ljava/lang/String;)Ljava/util/function/Function;",
+            "line": 330,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "append",
+            "desc": "(Ljava/lang/String;)Ljava/util/function/Function;",
+            "line": 334,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "join",
+            "desc": "(Ljava/lang/String;[Ljava/lang/String;)Ljava/lang/String;",
+            "line": 338,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "block",
+            "desc": "(Ljava/util/List;Lgraphql/language/Node;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
+            "line": 350,
+            "counters": {
+              "line": {
+                "covered": 24,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 18,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "indent",
+            "desc": "(Ljava/lang/String;)Ljava/lang/String;",
+            "line": 387,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "indent",
+            "desc": "(Ljava/lang/StringBuilder;)Ljava/lang/StringBuilder;",
+            "line": 391,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$block$4",
+            "desc": "(Ljava/lang/String;Z)Ljava/lang/String;",
+            "line": 375,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$block$3",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
+            "line": 374,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$block$2",
+            "desc": "(Lgraphql/language/Node;)J",
+            "line": 365,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$block$1",
+            "desc": "(Lgraphql/language/Node;)Lgraphql/language/AbstractDescribedNode;",
+            "line": 356,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$block$0",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 355,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$append$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
+            "line": 334,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$prepend$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
+            "line": 330,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$comments$0",
+            "desc": "(Ljava/lang/String;)Ljava/lang/String;",
+            "line": 299,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$unionTypeDefinition$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/StringBuilder;Lgraphql/language/UnionTypeDefinition;)V",
+            "line": 215,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 6
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$scalarTypeDefinition$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/StringBuilder;Lgraphql/language/ScalarTypeDefinition;)V",
+            "line": 203,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$implementingTypeDefinition$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/StringBuilder;Lgraphql/language/ImplementingTypeDefinition;)V",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$inputValueDefinition$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/StringBuilder;Lgraphql/language/InputValueDefinition;)V",
+            "line": 177,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$inputObjectTypeDefinition$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/StringBuilder;Lgraphql/language/InputObjectTypeDefinition;)V",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$fieldDefinition$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/FieldDefinition;)V",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$enumValueDefinition$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/EnumValueDefinition;)V",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$enumTypeDefinition$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/StringBuilder;Lgraphql/language/EnumTypeDefinition;)V",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$directiveDefinition$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/DirectiveDefinition;)V",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$document$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/Document;)V",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.PrettyAstPrinter$PrettyPrinterOptions": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/PrettyAstPrinter$PrettyPrinterOptions$IndentType;I)V",
+            "line": 414,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "defaultOptions",
+            "desc": "()Lgraphql/language/PrettyAstPrinter$PrettyPrinterOptions;",
+            "line": 419,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "builder",
+            "desc": "()Lgraphql/language/PrettyAstPrinter$PrettyPrinterOptions$Builder;",
+            "line": 423,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 412,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.ListType$Builder": {
+        "line": {
+          "covered": 12,
+          "missed": 13
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/ListType;)V",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 10
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "type",
+            "desc": "(Lgraphql/language/Type;)Lgraphql/language/ListType$Builder;",
+            "line": 133,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/ListType$Builder;",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/ListType$Builder;",
+            "line": 143,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/ListType$Builder;",
+            "line": 148,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/ListType$Builder;",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/ListType$Builder;",
+            "line": 158,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/ListType;",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.PrettyAstPrinter$PrettyPrinterOptions$Builder": {
+        "line": {
+          "covered": 7,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 437,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "indentType",
+            "desc": "(Lgraphql/language/PrettyAstPrinter$PrettyPrinterOptions$IndentType;)Lgraphql/language/PrettyAstPrinter$PrettyPrinterOptions$Builder;",
+            "line": 442,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "indentWith",
+            "desc": "(I)Lgraphql/language/PrettyAstPrinter$PrettyPrinterOptions$Builder;",
+            "line": 447,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/PrettyAstPrinter$PrettyPrinterOptions;",
+            "line": 452,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.AstPrinter": {
+        "line": {
+          "covered": 482,
+          "missed": 21
+        },
+        "branch": {
+          "covered": 194,
+          "missed": 22
+        },
+        "method": {
+          "covered": 96,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "full",
+            "desc": "()Lgraphql/language/AstPrinter;",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "compact",
+            "desc": "()Lgraphql/language/AstPrinter;",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Z)V",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 47,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "argument",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "document",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directive",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directiveDefinition",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directiveLocation",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enumTypeDefinition",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 154,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enumValue",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 168,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enumValueDefinition",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 172,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "field",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 183,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldDefinition",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 211,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasDescription",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 245,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fragmentDefinition",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 253,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fragmentSpread",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 265,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inlineFragment",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 273,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inputObjectTypeDefinition",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 299,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inputValueDefinition",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 315,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "interfaceTypeDefinition",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 336,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "objectField",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 356,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "operationDefinition",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 365,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "operationTypeDefinition",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 401,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "objectTypeDefinition",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 410,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "selectionSet",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 430,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "scalarTypeDefinition",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 434,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "schemaDefinition",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 447,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "type",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 460,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "type",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/Type;)V",
+            "line": 464,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "objectTypeExtensionDefinition",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 480,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enumTypeExtensionDefinition",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 487,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "interfaceTypeExtensionDefinition",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 494,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unionTypeExtensionDefinition",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 501,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "scalarTypeExtensionDefinition",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 508,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inputObjectTypeExtensionDefinition",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 515,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "schemaExtensionDefinition",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 522,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unionTypeDefinition",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 529,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "variableDefinition",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 546,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "variableReference",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 562,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "node",
+            "desc": "(Lgraphql/language/Node;)Ljava/lang/String;",
+            "line": 566,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "node",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/Node;)V",
+            "line": 570,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "node",
+            "desc": "(Lgraphql/language/Node;Ljava/lang/Class;)Ljava/lang/String;",
+            "line": 574,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "node",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/Node;Ljava/lang/Class;)V",
+            "line": 580,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "_findPrinter",
+            "desc": "(Lgraphql/language/Node;)Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 589,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "_findPrinter",
+            "desc": "(Lgraphql/language/Node;Ljava/lang/Class;)Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 593,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEmpty",
+            "desc": "(Ljava/util/List;)Z",
+            "line": 606,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEmpty",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 610,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "nvl",
+            "desc": "(Ljava/util/List;)Ljava/util/List;",
+            "line": 614,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "value",
+            "desc": "()Lgraphql/language/AstPrinter$NodePrinter;",
+            "line": 618,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "value",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/Value;)V",
+            "line": 622,
+            "counters": {
+              "line": {
+                "covered": 27,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 19,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/Node;)V",
+            "line": 652,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 9,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directives",
+            "desc": "(Ljava/lang/StringBuilder;Ljava/util/List;)V",
+            "line": 672,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "join",
+            "desc": "(Ljava/lang/StringBuilder;Ljava/util/List;Ljava/lang/String;)V",
+            "line": 676,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "joinTight",
+            "desc": "(Ljava/lang/StringBuilder;Ljava/util/List;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 693,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "wrap",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
+            "line": 711,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "block",
+            "desc": "(Ljava/lang/StringBuilder;Ljava/util/List;)V",
+            "line": 721,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "indent",
+            "desc": "(Ljava/lang/StringBuilder;I)V",
+            "line": 738,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "wrap",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Node;Ljava/lang/String;)Ljava/lang/String;",
+            "line": 749,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printAst",
+            "desc": "(Lgraphql/language/Node;)Ljava/lang/String;",
+            "line": 763,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printAstTo",
+            "desc": "(Lgraphql/language/Node;Ljava/lang/Appendable;)V",
+            "line": 776,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printAst",
+            "desc": "(Ljava/io/Writer;Lgraphql/language/Node;)V",
+            "line": 798,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printAstCompact",
+            "desc": "(Lgraphql/language/Node;)Ljava/lang/String;",
+            "line": 815,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printImpl",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/Node;Z)V",
+            "line": 821,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replacePrinter",
+            "desc": "(Ljava/lang/Class;Lgraphql/language/AstPrinter$NodePrinter;)V",
+            "line": 842,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$variableReference$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/VariableReference;)V",
+            "line": 562,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$variableDefinition$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/StringBuilder;Lgraphql/language/VariableDefinition;)V",
+            "line": 549,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$unionTypeDefinition$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/StringBuilder;Lgraphql/language/UnionTypeDefinition;)V",
+            "line": 532,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$schemaExtensionDefinition$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/SchemaExtensionDefinition;)V",
+            "line": 523,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$inputObjectTypeExtensionDefinition$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/InputObjectTypeExtensionDefinition;)V",
+            "line": 516,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$scalarTypeExtensionDefinition$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/ScalarTypeExtensionDefinition;)V",
+            "line": 509,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$unionTypeExtensionDefinition$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/UnionTypeExtensionDefinition;)V",
+            "line": 502,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$interfaceTypeExtensionDefinition$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/InterfaceTypeDefinition;)V",
+            "line": 495,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$enumTypeExtensionDefinition$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/EnumTypeExtensionDefinition;)V",
+            "line": 488,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$objectTypeExtensionDefinition$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/ObjectTypeExtensionDefinition;)V",
+            "line": 481,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$schemaDefinition$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/SchemaDefinition;)V",
+            "line": 448,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$scalarTypeDefinition$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/ScalarTypeDefinition;)V",
+            "line": 435,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$selectionSet$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/SelectionSet;)V",
+            "line": 430,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$objectTypeDefinition$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/ObjectTypeDefinition;)V",
+            "line": 411,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$operationTypeDefinition$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/StringBuilder;Lgraphql/language/OperationTypeDefinition;)V",
+            "line": 403,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$operationDefinition$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/StringBuilder;Lgraphql/language/OperationDefinition;)V",
+            "line": 367,
+            "counters": {
+              "line": {
+                "covered": 22,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 17,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$objectField$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/StringBuilder;Lgraphql/language/ObjectField;)V",
+            "line": 358,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$interfaceTypeDefinition$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/InterfaceTypeDefinition;)V",
+            "line": 337,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$inputValueDefinition$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/StringBuilder;Lgraphql/language/InputValueDefinition;)V",
+            "line": 318,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$inputObjectTypeDefinition$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/InputObjectTypeDefinition;)V",
+            "line": 300,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$inlineFragment$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/InlineFragment;)V",
+            "line": 274,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$fragmentSpread$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/FragmentSpread;)V",
+            "line": 266,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$fragmentDefinition$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/FragmentDefinition;)V",
+            "line": 254,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$fieldDefinition$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/StringBuilder;Lgraphql/language/FieldDefinition;)V",
+            "line": 213,
+            "counters": {
+              "line": {
+                "covered": 21,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$field$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/StringBuilder;Lgraphql/language/Field;)V",
+            "line": 186,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 12,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$enumValueDefinition$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/EnumValueDefinition;)V",
+            "line": 173,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$enumValue$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/EnumValue;)V",
+            "line": 168,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$enumTypeDefinition$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/EnumTypeDefinition;)V",
+            "line": 155,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$directiveLocation$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/DirectiveLocation;)V",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$directiveDefinition$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/StringBuilder;Lgraphql/language/DirectiveDefinition;)V",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$directive$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/StringBuilder;Lgraphql/language/Directive;)V",
+            "line": 119,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$document$1",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/Document;)V",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$document$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/Document;)V",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$argument$1",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/Argument;)V",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$argument$0",
+            "desc": "(Ljava/lang/StringBuilder;Lgraphql/language/Argument;)V",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.InputObjectTypeExtensionDefinition$Builder": {
+        "line": {
+          "covered": 29,
+          "missed": 12
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 8,
+          "missed": 6
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/InputObjectTypeDefinition;)V",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/InputObjectTypeExtensionDefinition$Builder;",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/InputObjectTypeExtensionDefinition$Builder;",
+            "line": 106,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/InputObjectTypeExtensionDefinition$Builder;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Lgraphql/language/Description;)Lgraphql/language/InputObjectTypeExtensionDefinition$Builder;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "directives",
+            "desc": "(Ljava/util/List;)Lgraphql/language/InputObjectTypeExtensionDefinition$Builder;",
+            "line": 122,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directive",
+            "desc": "(Lgraphql/language/Directive;)Lgraphql/language/InputObjectTypeExtensionDefinition$Builder;",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "inputValueDefinitions",
+            "desc": "(Ljava/util/List;)Lgraphql/language/InputObjectTypeExtensionDefinition$Builder;",
+            "line": 133,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inputValueDefinition",
+            "desc": "(Lgraphql/language/InputValueDefinition;)Lgraphql/language/InputObjectTypeExtensionDefinition$Builder;",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/InputObjectTypeExtensionDefinition$Builder;",
+            "line": 143,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/InputObjectTypeExtensionDefinition$Builder;",
+            "line": 148,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/InputObjectTypeExtensionDefinition$Builder;",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/InputObjectTypeExtensionDefinition;",
+            "line": 159,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.AstSignature": {
+        "line": {
+          "covered": 30,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 5,
+          "missed": 1
+        },
+        "method": {
+          "covered": 10,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "signatureQuery",
+            "desc": "(Lgraphql/language/Document;Ljava/lang/String;)Lgraphql/language/Document;",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "privacySafeQuery",
+            "desc": "(Lgraphql/language/Document;Ljava/lang/String;)Lgraphql/language/Document;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hideLiterals",
+            "desc": "(ZLgraphql/language/Document;)Lgraphql/language/Document;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "remapVariable",
+            "desc": "(Ljava/lang/String;Ljava/util/Map;Ljava/util/concurrent/atomic/AtomicInteger;)Ljava/lang/String;",
+            "line": 128,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "removeAliases",
+            "desc": "(Lgraphql/language/Document;)Lgraphql/language/Document;",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sortAST",
+            "desc": "(Lgraphql/language/Document;)Lgraphql/language/Document;",
+            "line": 147,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "dropUnusedQueryDefinitions",
+            "desc": "(Lgraphql/language/Document;Ljava/lang/String;)Lgraphql/language/Document;",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isThisOperation",
+            "desc": "(Lgraphql/language/OperationDefinition;Ljava/lang/String;)Z",
+            "line": 174,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transformDoc",
+            "desc": "(Lgraphql/language/Document;Lgraphql/language/NodeVisitorStub;)Lgraphql/language/Document;",
+            "line": 182,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.VariableDefinition": {
+        "line": {
+          "covered": 43,
+          "missed": 12
+        },
+        "branch": {
+          "covered": 5,
+          "missed": 3
+        },
+        "method": {
+          "covered": 15,
+          "missed": 8
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Type;Lgraphql/language/Value;Ljava/util/List;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Type;Lgraphql/language/Value;)V",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Type;)V",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefaultValue",
+            "desc": "()Lgraphql/language/Value;",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getType",
+            "desc": "()Lgraphql/language/Type;",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "hasDirective",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 109,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/VariableDefinition;",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/VariableDefinition;",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 165,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 175,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newVariableDefinition",
+            "desc": "()Lgraphql/language/VariableDefinition$Builder;",
+            "line": 180,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newVariableDefinition",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/VariableDefinition$Builder;",
+            "line": 184,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "newVariableDefinition",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Type;)Lgraphql/language/VariableDefinition$Builder;",
+            "line": 188,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newVariableDefinition",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Type;Lgraphql/language/Value;)Lgraphql/language/VariableDefinition$Builder;",
+            "line": 192,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/VariableDefinition;",
+            "line": 196,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/VariableDefinition$Builder;)V",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.Directive$Builder": {
+        "line": {
+          "covered": 25,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 8,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 145,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Directive;)V",
+            "line": 145,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/Directive$Builder;",
+            "line": 165,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/Directive$Builder;",
+            "line": 170,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/Directive$Builder;",
+            "line": 175,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "arguments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/Directive$Builder;",
+            "line": 180,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "argument",
+            "desc": "(Lgraphql/language/Argument;)Lgraphql/language/Directive$Builder;",
+            "line": 185,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/Directive$Builder;",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/Directive$Builder;",
+            "line": 195,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/Directive$Builder;",
+            "line": 200,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/Directive;",
+            "line": 206,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.ObjectTypeExtensionDefinition": {
+        "line": {
+          "covered": 9,
+          "missed": 16
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/List;Ljava/util/List;Ljava/util/List;Lgraphql/language/Description;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/ObjectTypeExtensionDefinition;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 9
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/ObjectTypeExtensionDefinition;",
+            "line": 63,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 5
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "newObjectTypeExtensionDefinition",
+            "desc": "()Lgraphql/language/ObjectTypeExtensionDefinition$Builder;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transformExtension",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/ObjectTypeExtensionDefinition;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/ObjectTypeExtensionDefinition$Builder;)V",
+            "line": 63,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.StringValue": {
+        "line": {
+          "covered": 21,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 3
+        },
+        "method": {
+          "covered": 13,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getValue",
+            "desc": "()Ljava/lang/String;",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/StringValue;",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/StringValue;",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/StringValue;",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newStringValue",
+            "desc": "()Lgraphql/language/StringValue$Builder;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newStringValue",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/StringValue$Builder;",
+            "line": 106,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/StringValue;",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.BooleanValue": {
+        "line": {
+          "covered": 20,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 4
+        },
+        "method": {
+          "covered": 12,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(ZLgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Z)V",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isValue",
+            "desc": "()Z",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/BooleanValue;",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 4
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/BooleanValue;",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Z)Lgraphql/language/BooleanValue;",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newBooleanValue",
+            "desc": "()Lgraphql/language/BooleanValue$Builder;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newBooleanValue",
+            "desc": "(Z)Lgraphql/language/BooleanValue$Builder;",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/BooleanValue;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.FragmentDefinition": {
+        "line": {
+          "covered": 42,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 3
+        },
+        "method": {
+          "covered": 15,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/TypeName;Ljava/util/List;Lgraphql/language/SelectionSet;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeCondition",
+            "desc": "()Lgraphql/language/TypeName;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "hasDirective",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSelectionSet",
+            "desc": "()Lgraphql/language/SelectionSet;",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/FragmentDefinition;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/FragmentDefinition;",
+            "line": 135,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 147,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 157,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newFragmentDefinition",
+            "desc": "()Lgraphql/language/FragmentDefinition$Builder;",
+            "line": 161,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/FragmentDefinition;",
+            "line": 165,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/FragmentDefinition$Builder;)V",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.InputValueDefinition$Builder": {
+        "line": {
+          "covered": 35,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 12,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 200,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/InputValueDefinition;)V",
+            "line": 200,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/InputValueDefinition$Builder;",
+            "line": 225,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/InputValueDefinition$Builder;",
+            "line": 230,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/InputValueDefinition$Builder;",
+            "line": 235,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "type",
+            "desc": "(Lgraphql/language/Type;)Lgraphql/language/InputValueDefinition$Builder;",
+            "line": 240,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "defaultValue",
+            "desc": "(Lgraphql/language/Value;)Lgraphql/language/InputValueDefinition$Builder;",
+            "line": 245,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Lgraphql/language/Description;)Lgraphql/language/InputValueDefinition$Builder;",
+            "line": 250,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directives",
+            "desc": "(Ljava/util/List;)Lgraphql/language/InputValueDefinition$Builder;",
+            "line": 256,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directive",
+            "desc": "(Lgraphql/language/Directive;)Lgraphql/language/InputValueDefinition$Builder;",
+            "line": 261,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/InputValueDefinition$Builder;",
+            "line": 266,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/InputValueDefinition$Builder;",
+            "line": 271,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/InputValueDefinition$Builder;",
+            "line": 276,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/InputValueDefinition;",
+            "line": 282,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.InlineFragment": {
+        "line": {
+          "covered": 42,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 5,
+          "missed": 3
+        },
+        "method": {
+          "covered": 15,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/TypeName;Ljava/util/List;Lgraphql/language/SelectionSet;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/TypeName;)V",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/TypeName;Lgraphql/language/SelectionSet;)V",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeCondition",
+            "desc": "()Lgraphql/language/TypeName;",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "hasDirective",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getSelectionSet",
+            "desc": "()Lgraphql/language/SelectionSet;",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/InlineFragment;",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/InlineFragment;",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 149,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 158,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newInlineFragment",
+            "desc": "()Lgraphql/language/InlineFragment$Builder;",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/InlineFragment;",
+            "line": 166,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/InlineFragment$Builder;)V",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.Document": {
+        "line": {
+          "covered": 35,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 3
+        },
+        "method": {
+          "covered": 20,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;)V",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefinitions",
+            "desc": "()Ljava/util/List;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefinitionsOfType",
+            "desc": "(Ljava/lang/Class;)Ljava/util/List;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFirstDefinitionOfType",
+            "desc": "(Ljava/lang/Class;)Ljava/util/Optional;",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOperationDefinition",
+            "desc": "(Ljava/lang/String;)Ljava/util/Optional;",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/Document;",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 122,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/Document;",
+            "line": 134,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newDocument",
+            "desc": "()Lgraphql/language/Document$Builder;",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/Document;",
+            "line": 154,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/Document$Builder;)V",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getOperationDefinition$1",
+            "desc": "(Ljava/lang/String;Lgraphql/language/OperationDefinition;)Z",
+            "line": 97,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getOperationDefinition$0",
+            "desc": "(Lgraphql/language/Definition;)Z",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getFirstDefinitionOfType$0",
+            "desc": "(Ljava/lang/Class;Lgraphql/language/Definition;)Z",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getDefinitionsOfType$0",
+            "desc": "(Ljava/lang/Class;Lgraphql/language/Definition;)Z",
+            "line": 63,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.NodeChildrenContainer$Builder": {
+        "line": {
+          "covered": 15,
+          "missed": 8
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)V",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "child",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Node;)Lgraphql/language/NodeChildrenContainer$Builder;",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "children",
+            "desc": "(Ljava/lang/String;Ljava/util/List;)Lgraphql/language/NodeChildrenContainer$Builder;",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "children",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/NodeChildrenContainer$Builder;",
+            "line": 97,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceChild",
+            "desc": "(Ljava/lang/String;ILgraphql/language/Node;)Lgraphql/language/NodeChildrenContainer$Builder;",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "removeChild",
+            "desc": "(Ljava/lang/String;I)Lgraphql/language/NodeChildrenContainer$Builder;",
+            "line": 109,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$children$0",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$child$0",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.OperationTypeDefinition": {
+        "line": {
+          "covered": 20,
+          "missed": 9
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 3
+        },
+        "method": {
+          "covered": 9,
+          "missed": 5
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/TypeName;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/TypeName;)V",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeName",
+            "desc": "()Lgraphql/language/TypeName;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/OperationTypeDefinition;",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/OperationTypeDefinition;",
+            "line": 97,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newOperationTypeDefinition",
+            "desc": "()Lgraphql/language/OperationTypeDefinition$Builder;",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/OperationTypeDefinition;",
+            "line": 118,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/OperationTypeDefinition$Builder;)V",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.ObjectField$Builder": {
+        "line": {
+          "covered": 17,
+          "missed": 10
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 5
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/ObjectField;)V",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/ObjectField$Builder;",
+            "line": 144,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/ObjectField$Builder;",
+            "line": 149,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/ObjectField$Builder;",
+            "line": 154,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "value",
+            "desc": "(Lgraphql/language/Value;)Lgraphql/language/ObjectField$Builder;",
+            "line": 159,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/ObjectField$Builder;",
+            "line": 164,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/ObjectField$Builder;",
+            "line": 169,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/ObjectField$Builder;",
+            "line": 174,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/ObjectField;",
+            "line": 180,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.ListType": {
+        "line": {
+          "covered": 18,
+          "missed": 7
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 3
+        },
+        "method": {
+          "covered": 11,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Type;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Type;)V",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getType",
+            "desc": "()Lgraphql/language/Type;",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/ListType;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/ListType;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newListType",
+            "desc": "()Lgraphql/language/ListType$Builder;",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newListType",
+            "desc": "(Lgraphql/language/Type;)Lgraphql/language/ListType$Builder;",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/ListType;",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/ListType$Builder;)V",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.Field": {
+        "line": {
+          "covered": 56,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 9,
+          "missed": 5
+        },
+        "method": {
+          "covered": 23,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/util/List;Lgraphql/language/SelectionSet;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/List;)V",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/List;Lgraphql/language/SelectionSet;)V",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/SelectionSet;)V",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 119,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/Field;",
+            "line": 128,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAlias",
+            "desc": "()Ljava/lang/String;",
+            "line": 141,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getResultKey",
+            "desc": "()Ljava/lang/String;",
+            "line": 145,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArguments",
+            "desc": "()Ljava/util/List;",
+            "line": 149,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 154,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 159,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 164,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "hasDirective",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 169,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getSelectionSet",
+            "desc": "()Lgraphql/language/SelectionSet;",
+            "line": 174,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 180,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 5
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/Field;",
+            "line": 194,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 208,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 219,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newField",
+            "desc": "()Lgraphql/language/Field$Builder;",
+            "line": 223,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newField",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/Field$Builder;",
+            "line": 227,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newField",
+            "desc": "(Ljava/lang/String;Lgraphql/language/SelectionSet;)Lgraphql/language/Field$Builder;",
+            "line": 231,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/Field;",
+            "line": 235,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/Field$Builder;)V",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.IntValue$Builder": {
+        "line": {
+          "covered": 20,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/IntValue;)V",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/IntValue$Builder;",
+            "line": 135,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "value",
+            "desc": "(Ljava/math/BigInteger;)Lgraphql/language/IntValue$Builder;",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "value",
+            "desc": "(I)Lgraphql/language/IntValue$Builder;",
+            "line": 145,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/IntValue$Builder;",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/IntValue$Builder;",
+            "line": 155,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/IntValue$Builder;",
+            "line": 160,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/IntValue$Builder;",
+            "line": 165,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/IntValue;",
+            "line": 170,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.DirectiveLocation$Builder": {
+        "line": {
+          "covered": 12,
+          "missed": 12
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/DirectiveLocation;)V",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 9
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/DirectiveLocation$Builder;",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/DirectiveLocation$Builder;",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/DirectiveLocation$Builder;",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/DirectiveLocation$Builder;",
+            "line": 141,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/DirectiveLocation$Builder;",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/DirectiveLocation$Builder;",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/DirectiveLocation;",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.ScalarTypeDefinition$Builder": {
+        "line": {
+          "covered": 30,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 10,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/ScalarTypeDefinition;)V",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/ScalarTypeDefinition$Builder;",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/ScalarTypeDefinition$Builder;",
+            "line": 167,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/ScalarTypeDefinition$Builder;",
+            "line": 172,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Lgraphql/language/Description;)Lgraphql/language/ScalarTypeDefinition$Builder;",
+            "line": 177,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directives",
+            "desc": "(Ljava/util/List;)Lgraphql/language/ScalarTypeDefinition$Builder;",
+            "line": 183,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directive",
+            "desc": "(Lgraphql/language/Directive;)Lgraphql/language/ScalarTypeDefinition$Builder;",
+            "line": 188,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/ScalarTypeDefinition$Builder;",
+            "line": 193,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/ScalarTypeDefinition$Builder;",
+            "line": 198,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/ScalarTypeDefinition$Builder;",
+            "line": 203,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/ScalarTypeDefinition;",
+            "line": 208,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.NodeUtil$GetOperationResult": {
+        "line": {
+          "covered": 1,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.AbstractDescribedNode": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;Lgraphql/language/Description;)V",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDescription",
+            "desc": "()Lgraphql/language/Description;",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.InputValueDefinition": {
+        "line": {
+          "covered": 44,
+          "missed": 8
+        },
+        "branch": {
+          "covered": 5,
+          "missed": 3
+        },
+        "method": {
+          "covered": 16,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Type;Lgraphql/language/Value;Ljava/util/List;Lgraphql/language/Description;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Type;)V",
+            "line": 63,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Type;Lgraphql/language/Value;)V",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getType",
+            "desc": "()Lgraphql/language/Type;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefaultValue",
+            "desc": "()Lgraphql/language/Value;",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 97,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "hasDirective",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 128,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/InputValueDefinition;",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 147,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/InputValueDefinition;",
+            "line": 161,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 174,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 184,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newInputValueDefinition",
+            "desc": "()Lgraphql/language/InputValueDefinition$Builder;",
+            "line": 188,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/InputValueDefinition;",
+            "line": 192,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/InputValueDefinition$Builder;)V",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.EnumValueDefinition$Builder": {
+        "line": {
+          "covered": 30,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 10,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 154,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/EnumValueDefinition;)V",
+            "line": 154,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/EnumValueDefinition$Builder;",
+            "line": 175,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/EnumValueDefinition$Builder;",
+            "line": 180,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/EnumValueDefinition$Builder;",
+            "line": 185,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Lgraphql/language/Description;)Lgraphql/language/EnumValueDefinition$Builder;",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directives",
+            "desc": "(Ljava/util/List;)Lgraphql/language/EnumValueDefinition$Builder;",
+            "line": 196,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directive",
+            "desc": "(Lgraphql/language/Directive;)Lgraphql/language/EnumValueDefinition$Builder;",
+            "line": 201,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/EnumValueDefinition$Builder;",
+            "line": 206,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/EnumValueDefinition$Builder;",
+            "line": 211,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/EnumValueDefinition$Builder;",
+            "line": 216,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/EnumValueDefinition;",
+            "line": 222,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.IntValue": {
+        "line": {
+          "covered": 20,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 3
+        },
+        "method": {
+          "covered": 12,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/math/BigInteger;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/math/BigInteger;)V",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getValue",
+            "desc": "()Ljava/math/BigInteger;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/IntValue;",
+            "line": 63,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/IntValue;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(I)Lgraphql/language/IntValue;",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newIntValue",
+            "desc": "()Lgraphql/language/IntValue$Builder;",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newIntValue",
+            "desc": "(Ljava/math/BigInteger;)Lgraphql/language/IntValue$Builder;",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/IntValue;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.Directive": {
+        "line": {
+          "covered": 27,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 3
+        },
+        "method": {
+          "covered": 15,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/List;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/List;)V",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArguments",
+            "desc": "()Ljava/util/List;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentsByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgument",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/Argument;",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/Directive;",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/Directive;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newDirective",
+            "desc": "()Lgraphql/language/Directive$Builder;",
+            "line": 133,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/Directive;",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/Directive$Builder;)V",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.EnumValue$Builder": {
+        "line": {
+          "covered": 12,
+          "missed": 12
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 122,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/EnumValue;)V",
+            "line": 122,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 9
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/EnumValue$Builder;",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/EnumValue$Builder;",
+            "line": 143,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/EnumValue$Builder;",
+            "line": 148,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/EnumValue$Builder;",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/EnumValue$Builder;",
+            "line": 158,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/EnumValue$Builder;",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/EnumValue;",
+            "line": 169,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.Argument": {
+        "line": {
+          "covered": 25,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 3
+        },
+        "method": {
+          "covered": 14,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Value;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Value;)V",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newArgument",
+            "desc": "()Lgraphql/language/Argument$Builder;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newArgument",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Value;)Lgraphql/language/Argument$Builder;",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getValue",
+            "desc": "()Lgraphql/language/Value;",
+            "line": 63,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/Argument;",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/Argument;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/Argument;",
+            "line": 119,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/Argument$Builder;)V",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.UnionTypeDefinition$Builder": {
+        "line": {
+          "covered": 35,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 12,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 169,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/UnionTypeDefinition;)V",
+            "line": 169,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/UnionTypeDefinition$Builder;",
+            "line": 191,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/UnionTypeDefinition$Builder;",
+            "line": 196,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/UnionTypeDefinition$Builder;",
+            "line": 201,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Lgraphql/language/Description;)Lgraphql/language/UnionTypeDefinition$Builder;",
+            "line": 206,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directives",
+            "desc": "(Ljava/util/List;)Lgraphql/language/UnionTypeDefinition$Builder;",
+            "line": 212,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directive",
+            "desc": "(Lgraphql/language/Directive;)Lgraphql/language/UnionTypeDefinition$Builder;",
+            "line": 217,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "memberTypes",
+            "desc": "(Ljava/util/List;)Lgraphql/language/UnionTypeDefinition$Builder;",
+            "line": 222,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "memberType",
+            "desc": "(Lgraphql/language/Type;)Lgraphql/language/UnionTypeDefinition$Builder;",
+            "line": 227,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/UnionTypeDefinition$Builder;",
+            "line": 232,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/UnionTypeDefinition$Builder;",
+            "line": 237,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/UnionTypeDefinition$Builder;",
+            "line": 242,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/UnionTypeDefinition;",
+            "line": 248,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.SchemaExtensionDefinition$Builder": {
+        "line": {
+          "covered": 24,
+          "missed": 10
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 5
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/SchemaDefinition;)V",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/language/SchemaExtensionDefinition$Builder;",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Lgraphql/language/SchemaExtensionDefinition$Builder;",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "directives",
+            "desc": "(Ljava/util/List;)Lgraphql/language/SchemaExtensionDefinition$Builder;",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directive",
+            "desc": "(Lgraphql/language/Directive;)Lgraphql/language/SchemaExtensionDefinition$Builder;",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "operationTypeDefinitions",
+            "desc": "(Ljava/util/List;)Lgraphql/language/SchemaExtensionDefinition$Builder;",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "operationTypeDefinition",
+            "desc": "(Lgraphql/language/OperationTypeDefinition;)Lgraphql/language/SchemaExtensionDefinition$Builder;",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "ignoredChars",
+            "desc": "(Lgraphql/language/IgnoredChars;)Lgraphql/language/SchemaExtensionDefinition$Builder;",
+            "line": 113,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/SchemaExtensionDefinition$Builder;",
+            "line": 118,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "additionalData",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/language/SchemaExtensionDefinition$Builder;",
+            "line": 123,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/language/SchemaExtensionDefinition;",
+            "line": 128,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.NodeTraverser$1": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/NodeTraverser;Lgraphql/language/NodeVisitor;)V",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enter",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "leave",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.NodeTraverser$2": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/NodeTraverser;Lgraphql/language/NodeVisitor;)V",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enter",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "leave",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.NodeTraverser$3": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/NodeTraverser;Lgraphql/language/NodeVisitor;)V",
+            "line": 133,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enter",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "leave",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 142,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.DirectiveDefinition": {
+        "line": {
+          "covered": 29,
+          "missed": 13
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 3
+        },
+        "method": {
+          "covered": 12,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;ZLgraphql/language/Description;Ljava/util/List;Ljava/util/List;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isRepeatable",
+            "desc": "()Z",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInputValueDefinitions",
+            "desc": "()Ljava/util/List;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectiveLocations",
+            "desc": "()Ljava/util/List;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/DirectiveDefinition;",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/DirectiveDefinition;",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 7
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 148,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newDirectiveDefinition",
+            "desc": "()Lgraphql/language/DirectiveDefinition$Builder;",
+            "line": 152,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/DirectiveDefinition;",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;Lgraphql/language/DirectiveDefinition$Builder;)V",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.DirectiveLocation": {
+        "line": {
+          "covered": 14,
+          "missed": 9
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 3
+        },
+        "method": {
+          "covered": 8,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/SourceLocation;Ljava/util/List;Lgraphql/language/IgnoredChars;Ljava/util/Map;)V",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNamedChildren",
+            "desc": "()Lgraphql/language/NodeChildrenContainer;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/language/NodeChildrenContainer;)Lgraphql/language/DirectiveLocation;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deepCopy",
+            "desc": "()Lgraphql/language/DirectiveLocation;",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/language/NodeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newDirectiveLocation",
+            "desc": "()Lgraphql/language/DirectiveLocation$Builder;",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/language/DirectiveLocation;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.AstSorter$1": {
+        "line": {
+          "covered": 95,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 37,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/AstSorter;)V",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitDocument",
+            "desc": "(Lgraphql/language/Document;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitOperationDefinition",
+            "desc": "(Lgraphql/language/OperationDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitField",
+            "desc": "(Lgraphql/language/Field;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitFragmentDefinition",
+            "desc": "(Lgraphql/language/FragmentDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitInlineFragment",
+            "desc": "(Lgraphql/language/InlineFragment;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitFragmentSpread",
+            "desc": "(Lgraphql/language/FragmentSpread;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitDirective",
+            "desc": "(Lgraphql/language/Directive;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitObjectValue",
+            "desc": "(Lgraphql/language/ObjectValue;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitSchemaDefinition",
+            "desc": "(Lgraphql/language/SchemaDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitEnumTypeDefinition",
+            "desc": "(Lgraphql/language/EnumTypeDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 145,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitScalarTypeDefinition",
+            "desc": "(Lgraphql/language/ScalarTypeDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 154,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitInputObjectTypeDefinition",
+            "desc": "(Lgraphql/language/InputObjectTypeDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitObjectTypeDefinition",
+            "desc": "(Lgraphql/language/ObjectTypeDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 172,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitInterfaceTypeDefinition",
+            "desc": "(Lgraphql/language/InterfaceTypeDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 182,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitUnionTypeDefinition",
+            "desc": "(Lgraphql/language/UnionTypeDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 192,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitFieldDefinition",
+            "desc": "(Lgraphql/language/FieldDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 201,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitInputValueDefinition",
+            "desc": "(Lgraphql/language/InputValueDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 210,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitDirectiveDefinition",
+            "desc": "(Lgraphql/language/DirectiveDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 219,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitDirectiveDefinition$0",
+            "desc": "(Lgraphql/language/DirectiveDefinition;Lgraphql/language/DirectiveDefinition$Builder;)V",
+            "line": 220,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitInputValueDefinition$0",
+            "desc": "(Lgraphql/language/InputValueDefinition;Lgraphql/language/InputValueDefinition$Builder;)V",
+            "line": 211,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitFieldDefinition$0",
+            "desc": "(Lgraphql/language/FieldDefinition;Lgraphql/language/FieldDefinition$Builder;)V",
+            "line": 202,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitUnionTypeDefinition$0",
+            "desc": "(Lgraphql/language/UnionTypeDefinition;Lgraphql/language/UnionTypeDefinition$Builder;)V",
+            "line": 193,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitInterfaceTypeDefinition$0",
+            "desc": "(Lgraphql/language/InterfaceTypeDefinition;Lgraphql/language/InterfaceTypeDefinition$Builder;)V",
+            "line": 183,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitObjectTypeDefinition$0",
+            "desc": "(Lgraphql/language/ObjectTypeDefinition;Lgraphql/language/ObjectTypeDefinition$Builder;)V",
+            "line": 173,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitInputObjectTypeDefinition$0",
+            "desc": "(Lgraphql/language/InputObjectTypeDefinition;Lgraphql/language/InputObjectTypeDefinition$Builder;)V",
+            "line": 164,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitScalarTypeDefinition$0",
+            "desc": "(Lgraphql/language/ScalarTypeDefinition;Lgraphql/language/ScalarTypeDefinition$Builder;)V",
+            "line": 155,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitEnumTypeDefinition$0",
+            "desc": "(Lgraphql/language/EnumTypeDefinition;Lgraphql/language/EnumTypeDefinition$Builder;)V",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitSchemaDefinition$0",
+            "desc": "(Lgraphql/language/SchemaDefinition;Lgraphql/language/SchemaDefinition$Builder;)V",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitObjectValue$0",
+            "desc": "(Lgraphql/language/ObjectValue;Lgraphql/language/ObjectValue$Builder;)V",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitDirective$0",
+            "desc": "(Lgraphql/language/Directive;Lgraphql/language/Directive$Builder;)V",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitFragmentSpread$0",
+            "desc": "(Lgraphql/language/FragmentSpread;Lgraphql/language/FragmentSpread$Builder;)V",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitInlineFragment$0",
+            "desc": "(Lgraphql/language/InlineFragment;Lgraphql/language/InlineFragment$Builder;)V",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitFragmentDefinition$0",
+            "desc": "(Lgraphql/language/FragmentDefinition;Lgraphql/language/FragmentDefinition$Builder;)V",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitField$0",
+            "desc": "(Lgraphql/language/Field;Lgraphql/language/Field$Builder;)V",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitOperationDefinition$0",
+            "desc": "(Lgraphql/language/OperationDefinition;Lgraphql/language/OperationDefinition$Builder;)V",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitDocument$0",
+            "desc": "(Lgraphql/language/Document;Lgraphql/language/Document$Builder;)V",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.language.AstComparator": {
+        "line": {
+          "covered": 13,
+          "missed": 14
+        },
+        "branch": {
+          "covered": 10,
+          "missed": 16
+        },
+        "method": {
+          "covered": 2,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "sameValue",
+            "desc": "(Lgraphql/language/Value;Lgraphql/language/Value;)Z",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 5
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEqual",
+            "desc": "(Lgraphql/language/Node;Lgraphql/language/Node;)Z",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 5
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEqual",
+            "desc": "(Ljava/util/List;Ljava/util/List;)Z",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 8
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 6
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.preparsed.NoOpPreparsedDocumentProvider": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 11,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDocumentAsync",
+            "desc": "(Lgraphql/ExecutionInput;Ljava/util/function/Function;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 12,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.preparsed.PreparsedDocumentEntry": {
+        "line": {
+          "covered": 21,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Document;Ljava/util/List;)V",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Document;)V",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;)V",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/GraphQLError;)V",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDocument",
+            "desc": "()Lgraphql/language/Document;",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrors",
+            "desc": "()Ljava/util/List;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasErrors",
+            "desc": "()Z",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.values.legacycoercing.LegacyCoercingInputInterceptor": {
+        "line": {
+          "covered": 53,
+          "missed": 13
+        },
+        "branch": {
+          "covered": 28,
+          "missed": 10
+        },
+        "method": {
+          "covered": 17,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "observesValues",
+            "desc": "(Ljava/util/function/BiConsumer;)Lgraphql/execution/values/legacycoercing/LegacyCoercingInputInterceptor;",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "migratesValues",
+            "desc": "()Lgraphql/execution/values/legacycoercing/LegacyCoercingInputInterceptor;",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "migratesValues",
+            "desc": "(Ljava/util/function/BiConsumer;)Lgraphql/execution/values/legacycoercing/LegacyCoercingInputInterceptor;",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/function/BiFunction;)V",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "intercept",
+            "desc": "(Ljava/lang/Object;Lgraphql/schema/GraphQLInputType;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isLegacyValue",
+            "desc": "(Ljava/lang/Object;Lgraphql/schema/GraphQLInputType;)Z",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isLegacyBooleanValue",
+            "desc": "(Ljava/lang/Object;)Z",
+            "line": 106,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isLegacyFloatValue",
+            "desc": "(Ljava/lang/Object;)Z",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isLegacyIntValue",
+            "desc": "(Ljava/lang/Object;)Z",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isLegacyStringValue",
+            "desc": "(Ljava/lang/Object;)Z",
+            "line": 118,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "coerceLegacyBooleanValue",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 122,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 7
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 5
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "coerceLegacyFloatValue",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "coerceLegacyIntValue",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 159,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "coerceLegacyStringValue",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 177,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$migratesValues$1",
+            "desc": "(Ljava/util/function/BiConsumer;Ljava/lang/Object;Lgraphql/schema/GraphQLInputType;)Ljava/lang/Object;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$migratesValues$0",
+            "desc": "(Ljava/lang/Object;Lgraphql/schema/GraphQLInputType;)V",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$observesValues$0",
+            "desc": "(Ljava/util/function/BiConsumer;Ljava/lang/Object;Lgraphql/schema/GraphQLInputType;)Ljava/lang/Object;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.ScalarInfo": {
+        "line": {
+          "covered": 10,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isGraphqlSpecifiedScalar",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isGraphqlSpecifiedScalar",
+            "desc": "(Lgraphql/schema/GraphQLScalarType;)Z",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inList",
+            "desc": "(Ljava/util/List;Ljava/lang/String;)Z",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$inList$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLScalarType;)Z",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.CombinedWiringFactory": {
+        "line": {
+          "covered": 53,
+          "missed": 16
+        },
+        "branch": {
+          "covered": 37,
+          "missed": 15
+        },
+        "method": {
+          "covered": 13,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;)V",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "providesTypeResolver",
+            "desc": "(Lgraphql/schema/idl/InterfaceWiringEnvironment;)Z",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeResolver",
+            "desc": "(Lgraphql/schema/idl/InterfaceWiringEnvironment;)Lgraphql/schema/TypeResolver;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "providesTypeResolver",
+            "desc": "(Lgraphql/schema/idl/UnionWiringEnvironment;)Z",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeResolver",
+            "desc": "(Lgraphql/schema/idl/UnionWiringEnvironment;)Lgraphql/schema/TypeResolver;",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "providesDataFetcherFactory",
+            "desc": "(Lgraphql/schema/idl/FieldWiringEnvironment;)Z",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDataFetcherFactory",
+            "desc": "(Lgraphql/schema/idl/FieldWiringEnvironment;)Lgraphql/schema/DataFetcherFactory;",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "providesDataFetcher",
+            "desc": "(Lgraphql/schema/idl/FieldWiringEnvironment;)Z",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDataFetcher",
+            "desc": "(Lgraphql/schema/idl/FieldWiringEnvironment;)Lgraphql/schema/DataFetcher;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "providesScalar",
+            "desc": "(Lgraphql/schema/idl/ScalarWiringEnvironment;)Z",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getScalar",
+            "desc": "(Lgraphql/schema/idl/ScalarWiringEnvironment;)Lgraphql/schema/GraphQLScalarType;",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "providesSchemaDirectiveWiring",
+            "desc": "(Lgraphql/schema/idl/SchemaDirectiveWiringEnvironment;)Z",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSchemaDirectiveWiring",
+            "desc": "(Lgraphql/schema/idl/SchemaDirectiveWiringEnvironment;)Lgraphql/schema/idl/SchemaDirectiveWiring;",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 5
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 4
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDefaultDataFetcher",
+            "desc": "(Lgraphql/schema/idl/FieldWiringEnvironment;)Lgraphql/schema/DataFetcher;",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.EchoingWiringFactory": {
+        "line": {
+          "covered": 39,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 12,
+          "missed": 4
+        },
+        "method": {
+          "covered": 14,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newEchoingWiring",
+            "desc": "()Lgraphql/schema/idl/RuntimeWiring;",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newEchoingWiring",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/schema/idl/RuntimeWiring;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "providesTypeResolver",
+            "desc": "(Lgraphql/schema/idl/InterfaceWiringEnvironment;)Z",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeResolver",
+            "desc": "(Lgraphql/schema/idl/InterfaceWiringEnvironment;)Lgraphql/schema/TypeResolver;",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "providesTypeResolver",
+            "desc": "(Lgraphql/schema/idl/UnionWiringEnvironment;)Z",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeResolver",
+            "desc": "(Lgraphql/schema/idl/UnionWiringEnvironment;)Lgraphql/schema/TypeResolver;",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefaultDataFetcher",
+            "desc": "(Lgraphql/schema/idl/FieldWiringEnvironment;)Lgraphql/schema/DataFetcher;",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fakeObjectValue",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;)Ljava/lang/Object;",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fakeScalarValue",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLScalarType;)Ljava/lang/Object;",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fakeScalar",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLScalarType;",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$fakeObjectValue$0",
+            "desc": "(Ljava/util/Map;Lgraphql/schema/GraphQLFieldDefinition;)V",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getDefaultDataFetcher$0",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getTypeResolver$1",
+            "desc": "(Lgraphql/TypeResolutionEnvironment;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$getTypeResolver$0",
+            "desc": "(Lgraphql/TypeResolutionEnvironment;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$newEchoingWiring$0",
+            "desc": "(Lgraphql/schema/idl/RuntimeWiring$Builder;)V",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.SchemaDirectiveWiringSchemaGeneratorPostProcessing$Visitor": {
+        "line": {
+          "covered": 34,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 15,
+          "missed": 3
+        },
+        "method": {
+          "covered": 12,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/idl/SchemaDirectiveWiringSchemaGeneratorPostProcessing;)V",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "schemaChanged",
+            "desc": "()Z",
+            "line": 63,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkBehaviourParams",
+            "desc": "()Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "changOrContinue",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;Lgraphql/schema/GraphQLSchemaElement;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isIntrospectionType",
+            "desc": "(Lgraphql/schema/GraphQLNamedType;)Z",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "notSuitable",
+            "desc": "(Lgraphql/schema/GraphQLNamedType;Ljava/util/function/Function;)Z",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLObjectType",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInterfaceType",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLEnumType",
+            "desc": "(Lgraphql/schema/GraphQLEnumType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputObjectType",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 119,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLScalarType",
+            "desc": "(Lgraphql/schema/GraphQLScalarType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 128,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLUnionType",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.SchemaTypeChecker": {
+        "line": {
+          "covered": 172,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 19,
+          "missed": 1
+        },
+        "method": {
+          "covered": 61,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkTypeRegistry",
+            "desc": "(Lgraphql/schema/idl/ImmutableTypeDefinitionRegistry;Lgraphql/schema/idl/RuntimeWiring;)Ljava/util/List;",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkForMissingTypes",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;)V",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkDirectiveDefinitions",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/List;)V",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkScalarImplementationsArePresent",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/schema/idl/RuntimeWiring;)V",
+            "line": 164,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkFieldsAreSensible",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;)V",
+            "line": 174,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkObjTypeFields",
+            "desc": "(Ljava/util/List;Lgraphql/language/ObjectTypeDefinition;Ljava/util/List;Ljava/util/Map;)V",
+            "line": 197,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkInterfaceFields",
+            "desc": "(Ljava/util/List;Lgraphql/language/InterfaceTypeDefinition;Ljava/util/List;Ljava/util/Map;)V",
+            "line": 215,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkEnumValues",
+            "desc": "(Ljava/util/List;Lgraphql/language/EnumTypeDefinition;Ljava/util/List;Ljava/util/Map;)V",
+            "line": 234,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkInputValues",
+            "desc": "(Ljava/util/List;Lgraphql/language/InputObjectTypeDefinition;Ljava/util/List;Lgraphql/introspection/Introspection$DirectiveLocation;Ljava/util/Map;)V",
+            "line": 250,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkNamedUniqueness",
+            "desc": "(Ljava/util/List;Ljava/util/List;Ljava/util/function/Function;Ljava/util/function/BiFunction;)V",
+            "line": 275,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkTypeResolversArePresent",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/schema/idl/RuntimeWiring;)V",
+            "line": 288,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkFieldTypesPresent",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/List;Lgraphql/language/TypeDefinition;Ljava/util/List;)V",
+            "line": 311,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkTypeExists",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/List;Lgraphql/language/TypeDefinition;)Ljava/util/function/Consumer;",
+            "line": 327,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkTypeExists",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/List;Ljava/lang/String;Lgraphql/language/Node;Ljava/lang/String;)Ljava/util/function/Consumer;",
+            "line": 337,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkInterfaceTypeExists",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/List;Lgraphql/language/TypeDefinition;)Ljava/util/function/Consumer;",
+            "line": 347,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filterTo",
+            "desc": "(Ljava/util/Map;Ljava/lang/Class;)Ljava/util/List;",
+            "line": 360,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$filterTo$0",
+            "desc": "(Ljava/lang/Class;Lgraphql/language/TypeDefinition;)Z",
+            "line": 360,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInterfaceTypeExists$0",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/List;Lgraphql/language/TypeDefinition;Lgraphql/language/Type;)V",
+            "line": 348,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTypeExists$1",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/List;Ljava/lang/String;Lgraphql/language/Node;Ljava/lang/String;Lgraphql/language/Type;)V",
+            "line": 338,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTypeExists$0",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/List;Ljava/lang/String;Lgraphql/language/TypeDefinition;Lgraphql/language/Type;)V",
+            "line": 328,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkFieldTypesPresent$0",
+            "desc": "(Lgraphql/language/FieldDefinition;)Ljava/util/List;",
+            "line": 315,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTypeResolversArePresent$5",
+            "desc": "(Lgraphql/language/TypeDefinition;)Z",
+            "line": 302,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTypeResolversArePresent$4",
+            "desc": "(Lgraphql/language/TypeDefinition;)Z",
+            "line": 295,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTypeResolversArePresent$3",
+            "desc": "(Ljava/util/List;Lgraphql/language/TypeDefinition;)V",
+            "line": 292,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTypeResolversArePresent$2",
+            "desc": "(Lgraphql/schema/idl/RuntimeWiring;Lgraphql/language/TypeDefinition;)Z",
+            "line": 291,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTypeResolversArePresent$1",
+            "desc": "(Lgraphql/schema/idl/RuntimeWiring;Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/language/UnionTypeDefinition;)Z",
+            "line": 289,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTypeResolversArePresent$0",
+            "desc": "(Lgraphql/schema/idl/RuntimeWiring;Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/language/InterfaceTypeDefinition;)Z",
+            "line": 288,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkNamedUniqueness$0",
+            "desc": "(Ljava/util/function/Function;Ljava/util/Set;Ljava/util/List;Ljava/util/function/BiFunction;Ljava/lang/Object;)V",
+            "line": 277,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInputValues$1",
+            "desc": "(Ljava/util/List;Lgraphql/language/InputObjectTypeDefinition;Lgraphql/language/InputValueDefinition;)V",
+            "line": 260,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInputValues$2",
+            "desc": "(Ljava/util/List;Lgraphql/language/InputObjectTypeDefinition;Lgraphql/language/InputValueDefinition;Lgraphql/language/Directive;)V",
+            "line": 261,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInputValues$3",
+            "desc": "(Lgraphql/language/InputObjectTypeDefinition;Lgraphql/language/InputValueDefinition;Ljava/lang/String;Lgraphql/language/Argument;)Lgraphql/schema/idl/errors/NonUniqueArgumentError;",
+            "line": 262,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInputValues$0",
+            "desc": "(Lgraphql/language/InputObjectTypeDefinition;Ljava/lang/String;Lgraphql/language/InputValueDefinition;)Lgraphql/schema/idl/errors/NonUniqueNameError;",
+            "line": 254,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkEnumValues$1",
+            "desc": "(Lgraphql/language/EnumTypeDefinition;Ljava/util/List;Lgraphql/language/EnumValueDefinition;)V",
+            "line": 239,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkEnumValues$2",
+            "desc": "(Lgraphql/language/EnumTypeDefinition;Lgraphql/language/EnumValueDefinition;Ljava/util/List;Lgraphql/language/Directive;)V",
+            "line": 241,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkEnumValues$3",
+            "desc": "(Lgraphql/language/EnumTypeDefinition;Lgraphql/language/EnumValueDefinition;Ljava/lang/String;Lgraphql/language/Argument;)Lgraphql/schema/idl/errors/NonUniqueArgumentError;",
+            "line": 241,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkEnumValues$0",
+            "desc": "(Lgraphql/language/EnumTypeDefinition;Ljava/lang/String;Lgraphql/language/EnumValueDefinition;)Lgraphql/schema/idl/errors/NonUniqueNameError;",
+            "line": 235,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInterfaceFields$3",
+            "desc": "(Ljava/util/List;Lgraphql/language/InterfaceTypeDefinition;Lgraphql/language/FieldDefinition;)V",
+            "line": 224,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInterfaceFields$4",
+            "desc": "(Ljava/util/List;Lgraphql/language/InterfaceTypeDefinition;Lgraphql/language/FieldDefinition;Lgraphql/language/Directive;)V",
+            "line": 226,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInterfaceFields$5",
+            "desc": "(Lgraphql/language/InterfaceTypeDefinition;Lgraphql/language/FieldDefinition;Ljava/lang/String;Lgraphql/language/Argument;)Lgraphql/schema/idl/errors/NonUniqueArgumentError;",
+            "line": 227,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInterfaceFields$1",
+            "desc": "(Ljava/util/List;Lgraphql/language/InterfaceTypeDefinition;Lgraphql/language/FieldDefinition;)V",
+            "line": 219,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInterfaceFields$2",
+            "desc": "(Lgraphql/language/InterfaceTypeDefinition;Lgraphql/language/FieldDefinition;Ljava/lang/String;Lgraphql/language/InputValueDefinition;)Lgraphql/schema/idl/errors/NonUniqueArgumentError;",
+            "line": 220,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInterfaceFields$0",
+            "desc": "(Lgraphql/language/InterfaceTypeDefinition;Ljava/lang/String;Lgraphql/language/FieldDefinition;)Lgraphql/schema/idl/errors/NonUniqueNameError;",
+            "line": 216,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$checkObjTypeFields$3",
+            "desc": "(Ljava/util/List;Lgraphql/language/ObjectTypeDefinition;Lgraphql/language/FieldDefinition;)V",
+            "line": 205,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkObjTypeFields$4",
+            "desc": "(Ljava/util/List;Lgraphql/language/ObjectTypeDefinition;Lgraphql/language/FieldDefinition;Lgraphql/language/Directive;)V",
+            "line": 207,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkObjTypeFields$5",
+            "desc": "(Lgraphql/language/ObjectTypeDefinition;Lgraphql/language/FieldDefinition;Ljava/lang/String;Lgraphql/language/Argument;)Lgraphql/schema/idl/errors/NonUniqueArgumentError;",
+            "line": 208,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkObjTypeFields$1",
+            "desc": "(Ljava/util/List;Lgraphql/language/ObjectTypeDefinition;Lgraphql/language/FieldDefinition;)V",
+            "line": 201,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkObjTypeFields$2",
+            "desc": "(Lgraphql/language/ObjectTypeDefinition;Lgraphql/language/FieldDefinition;Ljava/lang/String;Lgraphql/language/InputValueDefinition;)Lgraphql/schema/idl/errors/NonUniqueArgumentError;",
+            "line": 202,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkObjTypeFields$0",
+            "desc": "(Lgraphql/language/ObjectTypeDefinition;Ljava/lang/String;Lgraphql/language/FieldDefinition;)Lgraphql/schema/idl/errors/NonUniqueNameError;",
+            "line": 198,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkFieldsAreSensible$3",
+            "desc": "(Ljava/util/List;Ljava/util/Map;Lgraphql/language/InputObjectTypeDefinition;)V",
+            "line": 192,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkFieldsAreSensible$2",
+            "desc": "(Ljava/util/List;Ljava/util/Map;Lgraphql/language/EnumTypeDefinition;)V",
+            "line": 188,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkFieldsAreSensible$1",
+            "desc": "(Ljava/util/List;Ljava/util/Map;Lgraphql/language/InterfaceTypeDefinition;)V",
+            "line": 184,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkFieldsAreSensible$0",
+            "desc": "(Ljava/util/List;Ljava/util/Map;Lgraphql/language/ObjectTypeDefinition;)V",
+            "line": 180,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkScalarImplementationsArePresent$0",
+            "desc": "(Lgraphql/schema/idl/RuntimeWiring;Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/List;Ljava/lang/String;Lgraphql/language/ScalarTypeDefinition;)V",
+            "line": 165,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkDirectiveDefinitions$0",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/language/DirectiveDefinition;)V",
+            "line": 142,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkDirectiveDefinitions$2",
+            "desc": "(Ljava/util/List;Lgraphql/language/DirectiveDefinition;Lgraphql/language/DirectiveLocation;)V",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkDirectiveDefinitions$1",
+            "desc": "(Lgraphql/language/DirectiveDefinition;Ljava/lang/String;Lgraphql/language/InputValueDefinition;)Lgraphql/schema/idl/errors/NonUniqueNameError;",
+            "line": 145,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkForMissingTypes$4",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/List;Lgraphql/language/InputObjectTypeDefinition;)V",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkForMissingTypes$3",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/List;Lgraphql/language/UnionTypeDefinition;)V",
+            "line": 122,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkForMissingTypes$2",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/List;Lgraphql/language/InterfaceTypeDefinition;)V",
+            "line": 113,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkForMissingTypes$1",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/List;Lgraphql/language/ObjectTypeDefinition;)V",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkForMissingTypes$0",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/List;Lgraphql/language/ObjectTypeExtensionDefinition;)V",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.SchemaGeneratorDirectiveHelper$Parameters": {
+        "line": {
+          "covered": 23,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 13,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/schema/idl/RuntimeWiring;Ljava/util/Map;Lgraphql/schema/GraphQLCodeRegistry$Builder;)V",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/schema/idl/RuntimeWiring;Ljava/util/Map;Lgraphql/schema/GraphQLCodeRegistry$Builder;Lgraphql/language/NodeParentTree;Lgraphql/schema/GraphqlElementParentTree;Lgraphql/schema/GraphQLFieldsContainer;Lgraphql/schema/GraphQLFieldDefinition;)V",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeRegistry",
+            "desc": "()Lgraphql/schema/idl/TypeDefinitionRegistry;",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getRuntimeWiring",
+            "desc": "()Lgraphql/schema/idl/RuntimeWiring;",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNodeParentTree",
+            "desc": "()Lgraphql/language/NodeParentTree;",
+            "line": 109,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getElementParentTree",
+            "desc": "()Lgraphql/schema/GraphqlElementParentTree;",
+            "line": 113,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldsContainer",
+            "desc": "()Lgraphql/schema/GraphQLFieldsContainer;",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getContext",
+            "desc": "()Ljava/util/Map;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCodeRegistry",
+            "desc": "()Lgraphql/schema/GraphQLCodeRegistry$Builder;",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldsDefinition",
+            "desc": "()Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newParams",
+            "desc": "(Lgraphql/schema/GraphQLFieldsContainer;Lgraphql/language/NodeParentTree;Lgraphql/schema/GraphqlElementParentTree;)Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;",
+            "line": 133,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newParams",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/GraphQLFieldsContainer;Lgraphql/language/NodeParentTree;Lgraphql/schema/GraphqlElementParentTree;)Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newParams",
+            "desc": "(Lgraphql/language/NodeParentTree;Lgraphql/schema/GraphqlElementParentTree;)Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;",
+            "line": 141,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.WiringEnvironment": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;)V",
+            "line": 13,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getRegistry",
+            "desc": "()Lgraphql/schema/idl/TypeDefinitionRegistry;",
+            "line": 18,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.SchemaParseOrder": {
+        "line": {
+          "covered": 41,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 10,
+          "missed": 4
+        },
+        "method": {
+          "covered": 17,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInOrder",
+            "desc": "()Ljava/util/Map;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInNameOrder",
+            "desc": "()Ljava/util/Map;",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getElementComparator",
+            "desc": "()Ljava/util/Comparator;",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isAssignable",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;[Ljava/lang/Class;)Z",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sortValue",
+            "desc": "(Lgraphql/schema/GraphQLNamedSchemaElement;Ljava/util/Map;)Ljava/lang/Integer;",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildNameIndex",
+            "desc": "(Ljava/util/Map;)Ljava/util/Map;",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addDefinition",
+            "desc": "(Lgraphql/language/SDLDefinition;)Lgraphql/schema/idl/SchemaParseOrder;",
+            "line": 122,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "removeDefinition",
+            "desc": "(Lgraphql/language/SDLDefinition;)Lgraphql/schema/idl/SchemaParseOrder;",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "definitionList",
+            "desc": "(Lgraphql/language/SDLDefinition;)Ljava/util/List;",
+            "line": 142,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "computeIfAbsent",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 148,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$computeIfAbsent$0",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 148,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isAssignable$0",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;Ljava/lang/Class;)Z",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getElementComparator$0",
+            "desc": "(Ljava/util/Map;Lgraphql/schema/GraphQLSchemaElement;Lgraphql/schema/GraphQLSchemaElement;)I",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 4
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getInNameOrder$0",
+            "desc": "(Ljava/util/Map;Ljava/lang/String;Ljava/util/List;)V",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getInNameOrder$2",
+            "desc": "(Lgraphql/language/SDLDefinition;)Lgraphql/language/SDLNamedDefinition;",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getInNameOrder$1",
+            "desc": "(Lgraphql/language/SDLDefinition;)Z",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.MockedWiringFactory": {
+        "line": {
+          "covered": 10,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 9,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "providesTypeResolver",
+            "desc": "(Lgraphql/schema/idl/InterfaceWiringEnvironment;)Z",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeResolver",
+            "desc": "(Lgraphql/schema/idl/InterfaceWiringEnvironment;)Lgraphql/schema/TypeResolver;",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "providesTypeResolver",
+            "desc": "(Lgraphql/schema/idl/UnionWiringEnvironment;)Z",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeResolver",
+            "desc": "(Lgraphql/schema/idl/UnionWiringEnvironment;)Lgraphql/schema/TypeResolver;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "providesDataFetcher",
+            "desc": "(Lgraphql/schema/idl/FieldWiringEnvironment;)Z",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDataFetcher",
+            "desc": "(Lgraphql/schema/idl/FieldWiringEnvironment;)Lgraphql/schema/DataFetcher;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "providesScalar",
+            "desc": "(Lgraphql/schema/idl/ScalarWiringEnvironment;)Z",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getScalar",
+            "desc": "(Lgraphql/schema/idl/ScalarWiringEnvironment;)Lgraphql/schema/GraphQLScalarType;",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getTypeResolver$1",
+            "desc": "(Lgraphql/TypeResolutionEnvironment;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$getTypeResolver$0",
+            "desc": "(Lgraphql/TypeResolutionEnvironment;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.SchemaGeneratorHelper$BuildContext": {
+        "line": {
+          "covered": 43,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 5,
+          "missed": 1
+        },
+        "method": {
+          "covered": 18,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/idl/ImmutableTypeDefinitionRegistry;Lgraphql/schema/idl/RuntimeWiring;Ljava/util/Map;Lgraphql/schema/idl/SchemaGenerator$Options;)V",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isDirectiveWiringRequired",
+            "desc": "()Z",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeRegistry",
+            "desc": "()Lgraphql/schema/idl/TypeDefinitionRegistry;",
+            "line": 141,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeDefinition",
+            "desc": "(Lgraphql/language/Type;)Lgraphql/language/TypeDefinition;",
+            "line": 145,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "stackContains",
+            "desc": "(Lgraphql/schema/idl/TypeInfo;)Z",
+            "line": 154,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "push",
+            "desc": "(Lgraphql/schema/idl/TypeInfo;)V",
+            "line": 158,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "pop",
+            "desc": "()V",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasOutputType",
+            "desc": "(Lgraphql/language/TypeDefinition;)Lgraphql/schema/GraphQLOutputType;",
+            "line": 166,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasInputType",
+            "desc": "(Lgraphql/language/TypeDefinition;)Lgraphql/schema/GraphQLInputType;",
+            "line": 170,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "putOutputType",
+            "desc": "(Lgraphql/schema/GraphQLNamedOutputType;)V",
+            "line": 174,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "putInputType",
+            "desc": "(Lgraphql/schema/GraphQLNamedInputType;)V",
+            "line": 182,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getWiring",
+            "desc": "()Lgraphql/schema/idl/RuntimeWiring;",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getComparatorRegistry",
+            "desc": "()Lgraphql/schema/GraphqlTypeComparatorRegistry;",
+            "line": 194,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCodeRegistry",
+            "desc": "()Lgraphql/schema/GraphQLCodeRegistry$Builder;",
+            "line": 198,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addDirectiveDefinition",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)V",
+            "line": 202,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addDirectives",
+            "desc": "(Ljava/util/Set;)V",
+            "line": 206,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/Set;",
+            "line": 210,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypes",
+            "desc": "()Ljava/util/Set;",
+            "line": 218,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isCaptureAstDefinitions",
+            "desc": "()Z",
+            "line": 225,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.TypeUtil": {
+        "line": {
+          "covered": 16,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 11,
+          "missed": 5
+        },
+        "method": {
+          "covered": 5,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 11,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "simplePrint",
+            "desc": "(Lgraphql/language/Type;)Ljava/lang/String;",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unwrapAll",
+            "desc": "(Lgraphql/language/Type;)Lgraphql/language/TypeName;",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unwrapOne",
+            "desc": "(Lgraphql/language/Type;)Lgraphql/language/Type;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isNonNull",
+            "desc": "(Lgraphql/language/Type;)Z",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isList",
+            "desc": "(Lgraphql/language/Type;)Z",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isWrapped",
+            "desc": "(Lgraphql/language/Type;)Z",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 4
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.TypeRuntimeWiring": {
+        "line": {
+          "covered": 18,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 10,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "setStrictModeJvmWide",
+            "desc": "(Z)V",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getStrictModeJvmWide",
+            "desc": "()Z",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/DataFetcher;Ljava/util/Map;Lgraphql/schema/TypeResolver;Lgraphql/schema/idl/EnumValuesProvider;)V",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newTypeWiring",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/idl/TypeRuntimeWiring$Builder;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newTypeWiring",
+            "desc": "(Ljava/lang/String;Ljava/util/function/UnaryOperator;)Lgraphql/schema/idl/TypeRuntimeWiring;",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getTypeName",
+            "desc": "()Ljava/lang/String;",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDataFetchers",
+            "desc": "()Ljava/util/Map;",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefaultDataFetcher",
+            "desc": "()Lgraphql/schema/DataFetcher;",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeResolver",
+            "desc": "()Lgraphql/schema/TypeResolver;",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getEnumValuesProvider",
+            "desc": "()Lgraphql/schema/idl/EnumValuesProvider;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.SchemaExtensionsChecker": {
+        "line": {
+          "covered": 55,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 22,
+          "missed": 0
+        },
+        "method": {
+          "covered": 11,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "gatherOperationDefs",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;)Ljava/util/Map;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "gatherOperationDefs",
+            "desc": "(Ljava/util/List;Lgraphql/language/SchemaDefinition;Ljava/util/List;)Ljava/util/Map;",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "defineOperationDefs",
+            "desc": "(Ljava/util/List;Ljava/util/Collection;Ljava/util/Map;)V",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkSchemaInvariants",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;)Ljava/util/List;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "gatherSchemaDirectives",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;)Ljava/util/List;",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "gatherSchemaDirectives",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/List;)Ljava/util/List;",
+            "line": 97,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkOperationTypesExist",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/List;)Ljava/util/function/Consumer;",
+            "line": 109,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkOperationTypesAreObjects",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/List;)Ljava/util/function/Consumer;",
+            "line": 118,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkOperationTypesAreObjects$0",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/List;Lgraphql/language/OperationTypeDefinition;)V",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkOperationTypesExist$0",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/List;Lgraphql/language/OperationTypeDefinition;)V",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkSchemaInvariants$0",
+            "desc": "(Lgraphql/language/OperationTypeDefinition;)Z",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.SchemaDirectiveWiringEnvironmentImpl": {
+        "line": {
+          "covered": 33,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 14,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLDirectiveContainer;Ljava/util/List;Ljava/util/List;Lgraphql/schema/GraphQLAppliedDirective;Lgraphql/schema/GraphQLDirective;Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;)V",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getElement",
+            "desc": "()Lgraphql/schema/GraphQLDirectiveContainer;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirective",
+            "desc": "()Lgraphql/schema/GraphQLDirective;",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirective",
+            "desc": "()Lgraphql/schema/GraphQLAppliedDirective;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/Map;",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLDirective;",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirectives",
+            "desc": "()Ljava/util/Map;",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLAppliedDirective;",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "containsDirective",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNodeParentTree",
+            "desc": "()Lgraphql/language/NodeParentTree;",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getRegistry",
+            "desc": "()Lgraphql/schema/idl/TypeDefinitionRegistry;",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getBuildContext",
+            "desc": "()Ljava/util/Map;",
+            "line": 106,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCodeRegistry",
+            "desc": "()Lgraphql/schema/GraphQLCodeRegistry$Builder;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldsContainer",
+            "desc": "()Lgraphql/schema/GraphQLFieldsContainer;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getElementParentTree",
+            "desc": "()Lgraphql/schema/GraphqlElementParentTree;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinition",
+            "desc": "()Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDataFetcher",
+            "desc": "()Lgraphql/schema/DataFetcher;",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setFieldDataFetcher",
+            "desc": "(Lgraphql/schema/DataFetcher;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.TypeDefinitionRegistry": {
+        "line": {
+          "covered": 319,
+          "missed": 22
+        },
+        "branch": {
+          "covered": 154,
+          "missed": 22
+        },
+        "method": {
+          "covered": 64,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;Ljava/util/List;Lgraphql/language/SchemaDefinition;Lgraphql/schema/idl/SchemaParseOrder;)V",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "readOnly",
+            "desc": "()Lgraphql/schema/idl/ImmutableTypeDefinitionRegistry;",
+            "line": 118,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParseOrder",
+            "desc": "()Lgraphql/schema/idl/SchemaParseOrder;",
+            "line": 128,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "merge",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;)Lgraphql/schema/idl/TypeDefinitionRegistry;",
+            "line": 141,
+            "counters": {
+              "line": {
+                "covered": 25,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkMergeSchemaDefs",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/List;)Ljava/util/Map;",
+            "line": 213,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkAddOperationDefs",
+            "desc": "()Ljava/util/Optional;",
+            "line": 226,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addAll",
+            "desc": "(Ljava/util/Collection;)Ljava/util/Optional;",
+            "line": 243,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "add",
+            "desc": "(Lgraphql/language/SDLDefinition;)Ljava/util/Optional;",
+            "line": 261,
+            "counters": {
+              "line": {
+                "covered": 43,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 26,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "remove",
+            "desc": "(Lgraphql/language/SDLDefinition;)V",
+            "line": 319,
+            "counters": {
+              "line": {
+                "covered": 24,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 20,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "removeFromList",
+            "desc": "(Ljava/util/Map;Lgraphql/language/TypeDefinition;)V",
+            "line": 350,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "remove",
+            "desc": "(Ljava/lang/String;Lgraphql/language/SDLDefinition;)V",
+            "line": 367,
+            "counters": {
+              "line": {
+                "covered": 20,
+                "missed": 7
+              },
+              "branch": {
+                "covered": 15,
+                "missed": 7
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "removeFromMap",
+            "desc": "(Ljava/util/Map;Ljava/lang/String;)V",
+            "line": 398,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "define",
+            "desc": "(Ljava/util/Map;Ljava/util/Map;Lgraphql/language/TypeDefinition;)Ljava/util/Optional;",
+            "line": 406,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "define",
+            "desc": "(Ljava/util/Map;Ljava/util/Map;Lgraphql/language/DirectiveDefinition;)Ljava/util/Optional;",
+            "line": 419,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "defineExt",
+            "desc": "(Ljava/util/Map;Lgraphql/language/TypeDefinition;Ljava/util/function/Function;)Ljava/util/Optional;",
+            "line": 432,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "types",
+            "desc": "()Ljava/util/Map;",
+            "line": 439,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "scalars",
+            "desc": "()Ljava/util/Map;",
+            "line": 443,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "objectTypeExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 449,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "interfaceTypeExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 453,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unionTypeExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 457,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enumTypeExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 461,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "scalarTypeExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 465,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inputObjectTypeExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 469,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "schemaDefinition",
+            "desc": "()Ljava/util/Optional;",
+            "line": 473,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSchemaExtensionDefinitions",
+            "desc": "()Ljava/util/List;",
+            "line": 477,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleReDefinition",
+            "desc": "(Lgraphql/language/TypeDefinition;Lgraphql/language/TypeDefinition;)Lgraphql/GraphQLError;",
+            "line": 481,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleReDefinition",
+            "desc": "(Lgraphql/language/DirectiveDefinition;Lgraphql/language/DirectiveDefinition;)Lgraphql/GraphQLError;",
+            "line": 485,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectiveDefinition",
+            "desc": "(Ljava/lang/String;)Ljava/util/Optional;",
+            "line": 489,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectiveDefinitions",
+            "desc": "()Ljava/util/Map;",
+            "line": 493,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasType",
+            "desc": "(Lgraphql/language/TypeName;)Z",
+            "line": 504,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasType",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 516,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getType",
+            "desc": "(Lgraphql/language/Type;)Ljava/util/Optional;",
+            "line": 531,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getType",
+            "desc": "(Lgraphql/language/Type;Ljava/lang/Class;)Ljava/util/Optional;",
+            "line": 547,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getType",
+            "desc": "(Ljava/lang/String;)Ljava/util/Optional;",
+            "line": 562,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getType",
+            "desc": "(Ljava/lang/String;Ljava/lang/Class;)Ljava/util/Optional;",
+            "line": 576,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getTypeOrNull",
+            "desc": "(Lgraphql/language/Type;)Lgraphql/language/TypeDefinition;",
+            "line": 588,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeOrNull",
+            "desc": "(Lgraphql/language/Type;Ljava/lang/Class;)Lgraphql/language/TypeDefinition;",
+            "line": 601,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeOrNull",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/TypeDefinition;",
+            "line": 613,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeOrNull",
+            "desc": "(Ljava/lang/String;Ljava/lang/Class;)Lgraphql/language/TypeDefinition;",
+            "line": 631,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isInterfaceOrUnion",
+            "desc": "(Lgraphql/language/Type;)Z",
+            "line": 649,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isObjectTypeOrInterface",
+            "desc": "(Lgraphql/language/Type;)Z",
+            "line": 664,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isObjectType",
+            "desc": "(Lgraphql/language/Type;)Z",
+            "line": 679,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypes",
+            "desc": "(Ljava/lang/Class;)Ljava/util/List;",
+            "line": 691,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypesMap",
+            "desc": "(Ljava/lang/Class;)Ljava/util/Map;",
+            "line": 706,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllImplementationsOf",
+            "desc": "(Lgraphql/language/InterfaceTypeDefinition;)Ljava/util/List;",
+            "line": 720,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getImplementationsOf",
+            "desc": "(Lgraphql/language/InterfaceTypeDefinition;)Ljava/util/List;",
+            "line": 746,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isPossibleType",
+            "desc": "(Lgraphql/language/Type;Lgraphql/language/Type;)Z",
+            "line": 762,
+            "counters": {
+              "line": {
+                "covered": 25,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 20,
+                "missed": 4
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isSubTypeOf",
+            "desc": "(Lgraphql/language/Type;Lgraphql/language/Type;)Z",
+            "line": 811,
+            "counters": {
+              "line": {
+                "covered": 20,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 18,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getImplementationsOf$1",
+            "desc": "(Lgraphql/language/ImplementingTypeDefinition;)Lgraphql/language/ObjectTypeDefinition;",
+            "line": 749,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getImplementationsOf$0",
+            "desc": "(Lgraphql/language/ImplementingTypeDefinition;)Z",
+            "line": 748,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getAllImplementationsOf$0",
+            "desc": "(Lgraphql/language/InterfaceTypeDefinition;Lgraphql/language/ImplementingTypeDefinition;)Z",
+            "line": 723,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$defineExt$0",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 432,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$merge$13",
+            "desc": "(Ljava/lang/String;Ljava/util/List;)V",
+            "line": 204,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$merge$14",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 205,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$merge$11",
+            "desc": "(Ljava/lang/String;Ljava/util/List;)V",
+            "line": 199,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$merge$12",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 200,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$merge$9",
+            "desc": "(Ljava/lang/String;Ljava/util/List;)V",
+            "line": 194,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$merge$10",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 195,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$merge$7",
+            "desc": "(Ljava/lang/String;Ljava/util/List;)V",
+            "line": 189,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$merge$8",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$merge$5",
+            "desc": "(Ljava/lang/String;Ljava/util/List;)V",
+            "line": 184,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$merge$6",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 185,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$merge$3",
+            "desc": "(Ljava/lang/String;Ljava/util/List;)V",
+            "line": 179,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$merge$4",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 180,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$merge$2",
+            "desc": "(Ljava/util/Map;Ljava/util/List;Lgraphql/language/ScalarTypeDefinition;)V",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$merge$1",
+            "desc": "(Ljava/util/Map;Ljava/util/List;Lgraphql/language/DirectiveDefinition;)V",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$merge$0",
+            "desc": "(Ljava/util/Map;Ljava/util/List;Lgraphql/language/TypeDefinition;)V",
+            "line": 145,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.UnionTypesChecker": {
+        "line": {
+          "covered": 27,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 13,
+          "missed": 1
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkUnionType",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;)V",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkUnionType",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/language/UnionTypeDefinition;Ljava/util/List;)V",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 18,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 9,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertTypeName",
+            "desc": "(Lgraphql/language/UnionTypeDefinition;Ljava/util/List;)V",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkUnionType$0",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/List;Lgraphql/language/UnionTypeDefinition;)V",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.SchemaGeneratorHelper": {
+        "line": {
+          "covered": 508,
+          "missed": 9
+        },
+        "branch": {
+          "covered": 150,
+          "missed": 34
+        },
+        "method": {
+          "covered": 74,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildDescription",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/Node;Lgraphql/language/Description;)Ljava/lang/String;",
+            "line": 230,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildDeprecationReason",
+            "desc": "(Ljava/util/List;)Ljava/lang/String;",
+            "line": 253,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inputTypeFactory",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;)Ljava/util/function/Function;",
+            "line": 270,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildInputType",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/Type;)Lgraphql/schema/GraphQLInputType;",
+            "line": 275,
+            "counters": {
+              "line": {
+                "covered": 18,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildInputObjectType",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/InputObjectTypeDefinition;)Lgraphql/schema/GraphQLInputObjectType;",
+            "line": 307,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildInputField",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/InputValueDefinition;)Lgraphql/schema/GraphQLInputObjectField;",
+            "line": 341,
+            "counters": {
+              "line": {
+                "covered": 19,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildEnumType",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/EnumTypeDefinition;)Lgraphql/schema/GraphQLEnumType;",
+            "line": 370,
+            "counters": {
+              "line": {
+                "covered": 18,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildEnumValue",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/EnumTypeDefinition;Lgraphql/schema/idl/EnumValuesProvider;Lgraphql/language/EnumValueDefinition;)Lgraphql/schema/GraphQLEnumValueDefinition;",
+            "line": 410,
+            "counters": {
+              "line": {
+                "covered": 23,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildScalar",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/ScalarTypeDefinition;)Lgraphql/schema/GraphQLScalarType;",
+            "line": 445,
+            "counters": {
+              "line": {
+                "covered": 18,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getScalarDesc",
+            "desc": "(Lgraphql/schema/GraphQLScalarType;Lgraphql/language/ScalarTypeDefinition;)Ljava/lang/String;",
+            "line": 485,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSpecifiedByUrl",
+            "desc": "(Lgraphql/language/ScalarTypeDefinition;Ljava/util/List;)Ljava/lang/String;",
+            "line": 497,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeResolverForInterface",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/InterfaceTypeDefinition;)Lgraphql/schema/TypeResolver;",
+            "line": 510,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeResolverForUnion",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/UnionTypeDefinition;)Lgraphql/schema/TypeResolver;",
+            "line": 533,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildInterfaceTypeInterfaces",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/InterfaceTypeDefinition;Lgraphql/schema/GraphQLInterfaceType$Builder;Ljava/util/List;)V",
+            "line": 559,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildOperation",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/OperationTypeDefinition;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 584,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildInterfaceType",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/InterfaceTypeDefinition;)Lgraphql/schema/GraphQLInterfaceType;",
+            "line": 588,
+            "counters": {
+              "line": {
+                "covered": 22,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildObjectType",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/ObjectTypeDefinition;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 630,
+            "counters": {
+              "line": {
+                "covered": 18,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildObjectTypeInterfaces",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/ObjectTypeDefinition;Lgraphql/schema/GraphQLObjectType$Builder;Ljava/util/List;)V",
+            "line": 669,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildUnionType",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/UnionTypeDefinition;)Lgraphql/schema/GraphQLUnionType;",
+            "line": 694,
+            "counters": {
+              "line": {
+                "covered": 21,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildOutputType",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/Type;)Lgraphql/schema/GraphQLOutputType;",
+            "line": 753,
+            "counters": {
+              "line": {
+                "covered": 22,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 14,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildField",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/TypeDefinition;Lgraphql/language/FieldDefinition;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 790,
+            "counters": {
+              "line": {
+                "covered": 22,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildDataFetcherFactory",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/TypeDefinition;Lgraphql/language/FieldDefinition;Lgraphql/schema/GraphQLOutputType;Ljava/util/List;Ljava/util/List;)Ljava/util/Optional;",
+            "line": 838,
+            "counters": {
+              "line": {
+                "covered": 24,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildArgument",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/InputValueDefinition;)Lgraphql/schema/GraphQLArgument;",
+            "line": 882,
+            "counters": {
+              "line": {
+                "covered": 19,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildOperations",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/schema/GraphQLSchema$Builder;)V",
+            "line": 913,
+            "counters": {
+              "line": {
+                "covered": 30,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 14,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildSchemaDirectivesAndExtensions",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/schema/GraphQLSchema$Builder;)V",
+            "line": 961,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inputObjectTypeExtensions",
+            "desc": "(Lgraphql/language/InputObjectTypeDefinition;Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;)Ljava/util/List;",
+            "line": 980,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enumTypeExtensions",
+            "desc": "(Lgraphql/language/EnumTypeDefinition;Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;)Ljava/util/List;",
+            "line": 984,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "scalarTypeExtensions",
+            "desc": "(Lgraphql/language/ScalarTypeDefinition;Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;)Ljava/util/List;",
+            "line": 988,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "interfaceTypeExtensions",
+            "desc": "(Lgraphql/language/InterfaceTypeDefinition;Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;)Ljava/util/List;",
+            "line": 992,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "objectTypeExtensions",
+            "desc": "(Lgraphql/language/ObjectTypeDefinition;Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;)Ljava/util/List;",
+            "line": 996,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unionTypeExtensions",
+            "desc": "(Lgraphql/language/UnionTypeDefinition;Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;)Ljava/util/List;",
+            "line": 1000,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildAdditionalTypes",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;)Ljava/util/Set;",
+            "line": 1012,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDetachedTypeNames",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;)Ljava/util/Set;",
+            "line": 1065,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildAdditionalDirectiveDefinitions",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;)Ljava/util/Set;",
+            "line": 1081,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addDirectivesIncludedByDefault",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;)V",
+            "line": 1099,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOperationNamed",
+            "desc": "(Ljava/lang/String;Ljava/util/Map;)Ljava/util/Optional;",
+            "line": 1105,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "dataFetcherOfLastResort",
+            "desc": "()Lgraphql/schema/DataFetcher;",
+            "line": 1109,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "directivesOf",
+            "desc": "(Ljava/util/List;)Ljava/util/List;",
+            "line": 1113,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directivesObserve",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/schema/GraphQLDirectiveContainer;)Lgraphql/schema/GraphQLDirectiveContainer;",
+            "line": 1120,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildAdditionalTypes$3",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Ljava/util/Set;Lgraphql/language/ScalarTypeDefinition;)V",
+            "line": 1039,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildAdditionalTypes$2",
+            "desc": "(Ljava/util/Set;Lgraphql/language/ScalarTypeDefinition;)Z",
+            "line": 1037,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildAdditionalTypes$1",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Ljava/util/Set;Lgraphql/language/TypeDefinition;)V",
+            "line": 1021,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildAdditionalTypes$0",
+            "desc": "(Ljava/util/Set;Lgraphql/language/TypeDefinition;)Z",
+            "line": 1019,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildField$1",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/schema/FieldCoordinates;Lgraphql/schema/DataFetcherFactory;)V",
+            "line": 827,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildField$0",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition$Builder;Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/InputValueDefinition;)V",
+            "line": 808,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildUnionType$1",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/schema/GraphQLUnionType$Builder;Lgraphql/language/UnionTypeExtensionDefinition;)V",
+            "line": 722,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildUnionType$2",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/schema/GraphQLUnionType$Builder;Lgraphql/language/Type;)V",
+            "line": 723,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildUnionType$0",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/schema/GraphQLUnionType$Builder;Lgraphql/language/Type;)V",
+            "line": 704,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildObjectTypeInterfaces$3",
+            "desc": "(Lgraphql/schema/GraphQLObjectType$Builder;Lgraphql/schema/GraphQLOutputType;)V",
+            "line": 683,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildObjectTypeInterfaces$1",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Ljava/util/Map;Lgraphql/language/ObjectTypeExtensionDefinition;)V",
+            "line": 675,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildObjectTypeInterfaces$2",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Ljava/util/Map;Lgraphql/language/Type;)V",
+            "line": 676,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildObjectTypeInterfaces$0",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Ljava/util/Map;Lgraphql/language/Type;)V",
+            "line": 671,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildObjectType$1",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/ObjectTypeDefinition;Lgraphql/schema/GraphQLObjectType$Builder;Lgraphql/language/ObjectTypeExtensionDefinition;)V",
+            "line": 653,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildObjectType$2",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/ObjectTypeDefinition;Lgraphql/schema/GraphQLObjectType$Builder;Lgraphql/language/FieldDefinition;)V",
+            "line": 654,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildObjectType$0",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/ObjectTypeDefinition;Lgraphql/schema/GraphQLObjectType$Builder;Lgraphql/language/FieldDefinition;)V",
+            "line": 649,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildInterfaceType$1",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/InterfaceTypeDefinition;Lgraphql/schema/GraphQLInterfaceType$Builder;Lgraphql/language/InterfaceTypeExtensionDefinition;)V",
+            "line": 612,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildInterfaceType$2",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/InterfaceTypeDefinition;Lgraphql/schema/GraphQLInterfaceType$Builder;Lgraphql/language/FieldDefinition;)V",
+            "line": 613,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildInterfaceType$0",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/InterfaceTypeDefinition;Lgraphql/schema/GraphQLInterfaceType$Builder;Lgraphql/language/FieldDefinition;)V",
+            "line": 608,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildInterfaceTypeInterfaces$3",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType$Builder;Lgraphql/schema/GraphQLOutputType;)V",
+            "line": 573,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildInterfaceTypeInterfaces$1",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Ljava/util/Map;Lgraphql/language/InterfaceTypeExtensionDefinition;)V",
+            "line": 565,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildInterfaceTypeInterfaces$2",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Ljava/util/Map;Lgraphql/language/Type;)V",
+            "line": 566,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildInterfaceTypeInterfaces$0",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Ljava/util/Map;Lgraphql/language/Type;)V",
+            "line": 561,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getSpecifiedByUrl$1",
+            "desc": "(Lgraphql/language/Directive;)Z",
+            "line": 500,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getSpecifiedByUrl$0",
+            "desc": "(Ljava/util/List;Lgraphql/language/ScalarTypeExtensionDefinition;)V",
+            "line": 498,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildScalar$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/ScalarTypeDefinition;Ljava/util/List;Lgraphql/util/Pair;Lgraphql/schema/GraphQLScalarType$Builder;)V",
+            "line": 472,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildEnumType$1",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/EnumTypeDefinition;Lgraphql/schema/idl/EnumValuesProvider;Lgraphql/schema/GraphQLEnumType$Builder;Lgraphql/language/EnumTypeExtensionDefinition;)V",
+            "line": 385,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildEnumType$2",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/EnumTypeDefinition;Lgraphql/schema/idl/EnumValuesProvider;Lgraphql/schema/GraphQLEnumType$Builder;Lgraphql/language/EnumValueDefinition;)V",
+            "line": 386,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildEnumType$0",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/EnumTypeDefinition;Lgraphql/schema/idl/EnumValuesProvider;Lgraphql/schema/GraphQLEnumType$Builder;Lgraphql/language/EnumValueDefinition;)V",
+            "line": 381,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildInputObjectType$1",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/schema/GraphQLInputObjectType$Builder;Lgraphql/language/InputObjectTypeExtensionDefinition;)V",
+            "line": 330,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildInputObjectType$2",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/schema/GraphQLInputObjectType$Builder;Lgraphql/language/InputValueDefinition;)V",
+            "line": 331,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildInputObjectType$0",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType$Builder;Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/InputValueDefinition;)V",
+            "line": 328,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$inputTypeFactory$0",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/Type;)Lgraphql/schema/GraphQLInputType;",
+            "line": 270,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildDeprecationReason$1",
+            "desc": "(Lgraphql/language/Argument;)Ljava/lang/String;",
+            "line": 257,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildDeprecationReason$0",
+            "desc": "(Lgraphql/language/Directive;)Z",
+            "line": 254,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.NaturalEnumValuesProvider": {
+        "line": {
+          "covered": 5,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Class;)V",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getValue",
+            "desc": "(Ljava/lang/String;)Ljava/lang/Enum;",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.SchemaTypeExtensionsChecker": {
+        "line": {
+          "covered": 144,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 36,
+          "missed": 0
+        },
+        "method": {
+          "covered": 44,
+          "missed": 5
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkTypeExtensions",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;)V",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkObjectTypeExtensions",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/Map;)V",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkInterfaceTypeExtensions",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/Map;)V",
+            "line": 113,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkUnionTypeExtensions",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/Map;)V",
+            "line": 158,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkEnumTypeExtensions",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/Map;)V",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkScalarTypeExtensions",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/Map;)V",
+            "line": 221,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkInputObjectTypeExtensions",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/Map;)V",
+            "line": 237,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkTypeExtensionHasCorrespondingType",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/lang/String;Ljava/util/List;Ljava/lang/Class;)V",
+            "line": 271,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkForFieldRedefinition",
+            "desc": "(Ljava/util/List;Lgraphql/language/TypeDefinition;Ljava/util/List;Ljava/util/List;)V",
+            "line": 280,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkForInputValueRedefinition",
+            "desc": "(Ljava/util/List;Lgraphql/language/InputObjectTypeExtensionDefinition;Ljava/util/List;Ljava/util/List;)V",
+            "line": 290,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkForEnumValueRedefinition",
+            "desc": "(Ljava/util/List;Lgraphql/language/TypeDefinition;Ljava/util/List;Ljava/util/List;)V",
+            "line": 301,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkForTypeExtensionFieldUniqueness",
+            "desc": "(Ljava/util/List;Ljava/util/List;Ljava/util/function/Function;)V",
+            "line": 315,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkForTypeExtensionInputFieldUniqueness",
+            "desc": "(Ljava/util/List;Ljava/util/List;Ljava/util/function/Function;)V",
+            "line": 333,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkForTypeExtensionEnumFieldUniqueness",
+            "desc": "(Ljava/util/List;Ljava/util/List;Ljava/util/function/Function;)V",
+            "line": 351,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkForEnumValueRedefinition$0",
+            "desc": "(Ljava/util/Map;Ljava/util/List;Lgraphql/language/TypeDefinition;Lgraphql/language/EnumValueDefinition;)V",
+            "line": 304,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkForInputValueRedefinition$0",
+            "desc": "(Ljava/util/Map;Ljava/util/List;Lgraphql/language/InputObjectTypeExtensionDefinition;Lgraphql/language/InputValueDefinition;)V",
+            "line": 293,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkForFieldRedefinition$0",
+            "desc": "(Ljava/util/Map;Ljava/util/List;Lgraphql/language/TypeDefinition;Lgraphql/language/FieldDefinition;)V",
+            "line": 283,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInputObjectTypeExtensions$0",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/lang/String;Ljava/util/List;)V",
+            "line": 239,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInputObjectTypeExtensions$1",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/language/InputObjectTypeExtensionDefinition;)V",
+            "line": 242,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInputObjectTypeExtensions$3",
+            "desc": "(Ljava/util/List;Lgraphql/language/InputObjectTypeExtensionDefinition;Lgraphql/language/InputValueDefinition;)V",
+            "line": 248,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInputObjectTypeExtensions$4",
+            "desc": "(Ljava/util/List;Lgraphql/language/InputObjectTypeExtensionDefinition;Lgraphql/language/InputValueDefinition;Lgraphql/language/Directive;)V",
+            "line": 249,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInputObjectTypeExtensions$5",
+            "desc": "(Lgraphql/language/InputObjectTypeExtensionDefinition;Lgraphql/language/InputValueDefinition;Ljava/lang/String;Lgraphql/language/Argument;)Lgraphql/schema/idl/errors/NonUniqueArgumentError;",
+            "line": 250,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInputObjectTypeExtensions$2",
+            "desc": "(Lgraphql/language/InputObjectTypeExtensionDefinition;Ljava/lang/String;Lgraphql/language/InputValueDefinition;)Lgraphql/schema/idl/errors/NonUniqueNameError;",
+            "line": 245,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkScalarTypeExtensions$0",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/lang/String;Ljava/util/List;)V",
+            "line": 223,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkEnumTypeExtensions$0",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/lang/String;Ljava/util/List;)V",
+            "line": 192,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkEnumTypeExtensions$1",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/language/EnumTypeExtensionDefinition;)V",
+            "line": 196,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkEnumTypeExtensions$2",
+            "desc": "(Lgraphql/language/EnumTypeExtensionDefinition;Ljava/lang/String;Lgraphql/language/EnumValueDefinition;)Lgraphql/schema/idl/errors/NonUniqueNameError;",
+            "line": 198,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkUnionTypeExtensions$0",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/lang/String;Ljava/util/List;)V",
+            "line": 160,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkUnionTypeExtensions$1",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/language/UnionTypeExtensionDefinition;)V",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkUnionTypeExtensions$4",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/List;Lgraphql/language/UnionTypeExtensionDefinition;Lgraphql/language/TypeName;)V",
+            "line": 171,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkUnionTypeExtensions$3",
+            "desc": "(Lgraphql/language/UnionTypeExtensionDefinition;Ljava/lang/String;Lgraphql/language/TypeName;)Lgraphql/schema/idl/errors/NonUniqueNameError;",
+            "line": 167,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkUnionTypeExtensions$2",
+            "desc": "(Lgraphql/language/Type;)Lgraphql/language/TypeName;",
+            "line": 164,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInterfaceTypeExtensions$0",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/lang/String;Ljava/util/List;)V",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInterfaceTypeExtensions$1",
+            "desc": "(Ljava/util/List;Ljava/lang/String;Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/language/InterfaceTypeExtensionDefinition;)V",
+            "line": 118,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInterfaceTypeExtensions$5",
+            "desc": "(Ljava/util/List;Lgraphql/language/InterfaceTypeExtensionDefinition;Lgraphql/language/FieldDefinition;)V",
+            "line": 128,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInterfaceTypeExtensions$6",
+            "desc": "(Ljava/util/List;Lgraphql/language/InterfaceTypeExtensionDefinition;Lgraphql/language/FieldDefinition;Lgraphql/language/Directive;)V",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInterfaceTypeExtensions$7",
+            "desc": "(Lgraphql/language/InterfaceTypeExtensionDefinition;Lgraphql/language/FieldDefinition;Ljava/lang/String;Lgraphql/language/Argument;)Lgraphql/schema/idl/errors/NonUniqueArgumentError;",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInterfaceTypeExtensions$3",
+            "desc": "(Ljava/util/List;Lgraphql/language/InterfaceTypeExtensionDefinition;Ljava/lang/String;Lgraphql/language/FieldDefinition;)V",
+            "line": 124,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInterfaceTypeExtensions$4",
+            "desc": "(Lgraphql/language/InterfaceTypeExtensionDefinition;Lgraphql/language/FieldDefinition;Ljava/lang/String;Ljava/lang/String;Lgraphql/language/InputValueDefinition;)Lgraphql/schema/idl/errors/NonUniqueArgumentError;",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInterfaceTypeExtensions$2",
+            "desc": "(Lgraphql/language/InterfaceTypeExtensionDefinition;Ljava/lang/String;Lgraphql/language/FieldDefinition;)Lgraphql/schema/idl/errors/NonUniqueNameError;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$checkObjectTypeExtensions$0",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/lang/String;Ljava/util/List;)V",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkObjectTypeExtensions$1",
+            "desc": "(Ljava/util/List;Ljava/lang/String;Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/language/ObjectTypeExtensionDefinition;)V",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkObjectTypeExtensions$5",
+            "desc": "(Ljava/util/List;Lgraphql/language/ObjectTypeExtensionDefinition;Lgraphql/language/FieldDefinition;)V",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkObjectTypeExtensions$6",
+            "desc": "(Ljava/util/List;Lgraphql/language/ObjectTypeExtensionDefinition;Lgraphql/language/FieldDefinition;Lgraphql/language/Directive;)V",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkObjectTypeExtensions$7",
+            "desc": "(Lgraphql/language/ObjectTypeExtensionDefinition;Lgraphql/language/FieldDefinition;Ljava/lang/String;Lgraphql/language/Argument;)Lgraphql/schema/idl/errors/NonUniqueArgumentError;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkObjectTypeExtensions$3",
+            "desc": "(Ljava/util/List;Lgraphql/language/ObjectTypeExtensionDefinition;Ljava/lang/String;Lgraphql/language/FieldDefinition;)V",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkObjectTypeExtensions$4",
+            "desc": "(Lgraphql/language/ObjectTypeExtensionDefinition;Lgraphql/language/FieldDefinition;Ljava/lang/String;Ljava/lang/String;Lgraphql/language/InputValueDefinition;)Lgraphql/schema/idl/errors/NonUniqueArgumentError;",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkObjectTypeExtensions$2",
+            "desc": "(Lgraphql/language/ObjectTypeExtensionDefinition;Ljava/lang/String;Lgraphql/language/FieldDefinition;)Lgraphql/schema/idl/errors/NonUniqueNameError;",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.SchemaDirectiveWiring": {
+        "line": {
+          "covered": 5,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 5
+        },
+        "methods": [
+          {
+            "name": "onObject",
+            "desc": "(Lgraphql/schema/idl/SchemaDirectiveWiringEnvironment;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onField",
+            "desc": "(Lgraphql/schema/idl/SchemaDirectiveWiringEnvironment;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onArgument",
+            "desc": "(Lgraphql/schema/idl/SchemaDirectiveWiringEnvironment;)Lgraphql/schema/GraphQLArgument;",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onInterface",
+            "desc": "(Lgraphql/schema/idl/SchemaDirectiveWiringEnvironment;)Lgraphql/schema/GraphQLInterfaceType;",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "onUnion",
+            "desc": "(Lgraphql/schema/idl/SchemaDirectiveWiringEnvironment;)Lgraphql/schema/GraphQLUnionType;",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "onEnum",
+            "desc": "(Lgraphql/schema/idl/SchemaDirectiveWiringEnvironment;)Lgraphql/schema/GraphQLEnumType;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "onEnumValue",
+            "desc": "(Lgraphql/schema/idl/SchemaDirectiveWiringEnvironment;)Lgraphql/schema/GraphQLEnumValueDefinition;",
+            "line": 124,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "onScalar",
+            "desc": "(Lgraphql/schema/idl/SchemaDirectiveWiringEnvironment;)Lgraphql/schema/GraphQLScalarType;",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "onInputObjectType",
+            "desc": "(Lgraphql/schema/idl/SchemaDirectiveWiringEnvironment;)Lgraphql/schema/GraphQLInputObjectType;",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onInputObjectField",
+            "desc": "(Lgraphql/schema/idl/SchemaDirectiveWiringEnvironment;)Lgraphql/schema/GraphQLInputObjectField;",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.SchemaTypeDirectivesChecker": {
+        "line": {
+          "covered": 108,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 42,
+          "missed": 0
+        },
+        "method": {
+          "covered": 39,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/schema/idl/RuntimeWiring;)V",
+            "line": 63,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkTypeDirectives",
+            "desc": "(Ljava/util/List;)V",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 30,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkDirectives",
+            "desc": "(Lgraphql/introspection/Introspection$DirectiveLocation;Ljava/util/List;Lgraphql/language/TypeDefinition;)V",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkFieldsDirectives",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/List;)V",
+            "line": 128,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkDirectives",
+            "desc": "(Lgraphql/introspection/Introspection$DirectiveLocation;Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/language/Node;Ljava/lang/String;Ljava/util/List;)V",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inRightLocation",
+            "desc": "(Lgraphql/introspection/Introspection$DirectiveLocation;Lgraphql/language/DirectiveDefinition;)Z",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkDirectiveArguments",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/language/Node;Ljava/lang/String;Lgraphql/language/Directive;Lgraphql/language/DirectiveDefinition;)V",
+            "line": 160,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isNoNullArgWithoutDefaultValue",
+            "desc": "(Lgraphql/language/InputValueDefinition;)Z",
+            "line": 181,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "commonCheck",
+            "desc": "(Ljava/util/Collection;Ljava/util/List;)V",
+            "line": 185,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertTypeName",
+            "desc": "(Lgraphql/language/NamedNode;Ljava/util/List;)V",
+            "line": 198,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertExistAndIsInputType",
+            "desc": "(Lgraphql/language/InputValueDefinition;Ljava/util/List;)V",
+            "line": 204,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "findTypeDefFromRegistry",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/idl/TypeDefinitionRegistry;)Lgraphql/language/TypeDefinition;",
+            "line": 221,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$commonCheck$0",
+            "desc": "(Ljava/util/List;Lgraphql/language/DirectiveDefinition;)V",
+            "line": 186,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$commonCheck$1",
+            "desc": "(Ljava/util/List;Lgraphql/language/DirectiveDefinition;Lgraphql/language/InputValueDefinition;)V",
+            "line": 188,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkDirectiveArguments$1",
+            "desc": "(Ljava/util/Map;Ljava/util/List;Lgraphql/language/Node;Ljava/lang/String;Lgraphql/language/Directive;Ljava/lang/String;Lgraphql/language/InputValueDefinition;)V",
+            "line": 172,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkDirectiveArguments$0",
+            "desc": "(Ljava/util/Map;Ljava/util/List;Lgraphql/language/Node;Ljava/lang/String;Lgraphql/language/Directive;Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/language/Argument;)V",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkDirectives$2",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/List;Lgraphql/language/Node;Ljava/lang/String;Lgraphql/introspection/Introspection$DirectiveLocation;Lgraphql/language/Directive;)V",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkFieldsDirectives$0",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/language/FieldDefinition;)V",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkFieldsDirectives$1",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/language/InputValueDefinition;)V",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkDirectives$1",
+            "desc": "(Ljava/util/List;Lgraphql/language/InputValueDefinition;)V",
+            "line": 123,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkDirectives$0",
+            "desc": "(Ljava/util/List;Lgraphql/language/EnumValueDefinition;)V",
+            "line": 119,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTypeDirectives$17",
+            "desc": "(Ljava/util/List;Lgraphql/language/ScalarTypeDefinition;)V",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTypeDirectives$16",
+            "desc": "(Ljava/util/List;Lgraphql/language/InputObjectTypeDefinition;)V",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTypeDirectives$15",
+            "desc": "(Ljava/util/List;Lgraphql/language/EnumTypeDefinition;)V",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTypeDirectives$14",
+            "desc": "(Ljava/util/List;Lgraphql/language/UnionTypeDefinition;)V",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTypeDirectives$13",
+            "desc": "(Ljava/util/List;Lgraphql/language/InterfaceTypeDefinition;)V",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTypeDirectives$12",
+            "desc": "(Ljava/util/List;Lgraphql/language/ObjectTypeDefinition;)V",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTypeDirectives$10",
+            "desc": "(Ljava/util/List;Ljava/util/List;)V",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTypeDirectives$11",
+            "desc": "(Ljava/util/List;Lgraphql/language/InputObjectTypeExtensionDefinition;)V",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTypeDirectives$8",
+            "desc": "(Ljava/util/List;Ljava/util/List;)V",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTypeDirectives$9",
+            "desc": "(Ljava/util/List;Lgraphql/language/ScalarTypeExtensionDefinition;)V",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTypeDirectives$6",
+            "desc": "(Ljava/util/List;Ljava/util/List;)V",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTypeDirectives$7",
+            "desc": "(Ljava/util/List;Lgraphql/language/EnumTypeExtensionDefinition;)V",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTypeDirectives$4",
+            "desc": "(Ljava/util/List;Ljava/util/List;)V",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTypeDirectives$5",
+            "desc": "(Ljava/util/List;Lgraphql/language/UnionTypeExtensionDefinition;)V",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTypeDirectives$2",
+            "desc": "(Ljava/util/List;Ljava/util/List;)V",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTypeDirectives$3",
+            "desc": "(Ljava/util/List;Lgraphql/language/InterfaceTypeExtensionDefinition;)V",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTypeDirectives$0",
+            "desc": "(Ljava/util/List;Ljava/util/List;)V",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTypeDirectives$1",
+            "desc": "(Ljava/util/List;Lgraphql/language/ObjectTypeExtensionDefinition;)V",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.ImplementingTypesChecker": {
+        "line": {
+          "covered": 114,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 29,
+          "missed": 1
+        },
+        "method": {
+          "covered": 30,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkImplementingTypes",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;)V",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkImplementingType",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/language/ImplementingTypeDefinition;)V",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkInterfacesNotImplementedMoreThanOnce",
+            "desc": "(Ljava/util/List;Lgraphql/language/ImplementingTypeDefinition;Lgraphql/schema/idl/TypeDefinitionRegistry;)Ljava/util/Map;",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkAncestorImplementation",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/language/ImplementingTypeDefinition;Ljava/util/Map;)V",
+            "line": 119,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkInterfaceIsImplemented",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/language/ImplementingTypeDefinition;Ljava/util/Map;)V",
+            "line": 143,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkArgumentConsistency",
+            "desc": "(Ljava/lang/String;Lgraphql/language/ImplementingTypeDefinition;Lgraphql/language/InterfaceTypeDefinition;Lgraphql/language/FieldDefinition;Lgraphql/language/FieldDefinition;Ljava/util/List;)V",
+            "line": 181,
+            "counters": {
+              "line": {
+                "covered": 21,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 13,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLogicallyImplementedInterfaces",
+            "desc": "(Lgraphql/language/ImplementingTypeDefinition;Lgraphql/schema/idl/TypeDefinitionRegistry;)Ljava/util/Map;",
+            "line": 218,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLogicallyDeclaredFields",
+            "desc": "(Lgraphql/language/ImplementingTypeDefinition;Lgraphql/schema/idl/TypeDefinitionRegistry;)Ljava/util/Set;",
+            "line": 241,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mergeFirstValue",
+            "desc": "()Ljava/util/function/BinaryOperator;",
+            "line": 255,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toInterfaceTypeDefinition",
+            "desc": "(Lgraphql/language/Type;Lgraphql/schema/idl/TypeDefinitionRegistry;)Lgraphql/language/InterfaceTypeDefinition;",
+            "line": 259,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toInterfaceTypeDefinitions",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/Collection;)Ljava/util/Set;",
+            "line": 266,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$toInterfaceTypeDefinitions$0",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/language/Type;)Lgraphql/language/InterfaceTypeDefinition;",
+            "line": 267,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$mergeFirstValue$0",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 255,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getLogicallyDeclaredFields$0",
+            "desc": "(Lgraphql/language/ImplementingTypeDefinition;)Ljava/util/stream/Stream;",
+            "line": 248,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getLogicallyImplementedInterfaces$0",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Ljava/util/HashMap;Lgraphql/language/ImplementingTypeDefinition;)V",
+            "line": 225,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getLogicallyImplementedInterfaces$1",
+            "desc": "(Ljava/util/HashMap;Lgraphql/language/ImplementingTypeDefinition;Lgraphql/language/InterfaceTypeDefinition;)V",
+            "line": 228,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkArgumentConsistency$1",
+            "desc": "(Lgraphql/language/InputValueDefinition$Builder;)V",
+            "line": 191,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkArgumentConsistency$0",
+            "desc": "(Lgraphql/language/InputValueDefinition$Builder;)V",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInterfaceIsImplemented$0",
+            "desc": "(Ljava/util/Map;Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/language/InterfaceTypeDefinition;Lgraphql/language/ImplementingTypeDefinition;)V",
+            "line": 149,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInterfaceIsImplemented$1",
+            "desc": "(Ljava/util/Map;Ljava/util/List;Lgraphql/language/ImplementingTypeDefinition;Lgraphql/language/InterfaceTypeDefinition;Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/language/FieldDefinition;)V",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkAncestorImplementation$0",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/language/ImplementingTypeDefinition;Ljava/util/List;Ljava/util/Map;Lgraphql/language/InterfaceTypeDefinition;Lgraphql/language/ImplementingTypeDefinition;)V",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkAncestorImplementation$1",
+            "desc": "(Lgraphql/language/ImplementingTypeDefinition;Ljava/util/List;Lgraphql/language/InterfaceTypeDefinition;Ljava/util/Map;Lgraphql/language/ImplementingTypeDefinition;Lgraphql/language/InterfaceTypeDefinition;)V",
+            "line": 128,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInterfacesNotImplementedMoreThanOnce$3",
+            "desc": "(Ljava/util/List;Ljava/util/Map$Entry;)V",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInterfacesNotImplementedMoreThanOnce$4",
+            "desc": "(Ljava/util/List;Ljava/util/Map$Entry;Lgraphql/language/ImplementingTypeDefinition;)V",
+            "line": 106,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInterfacesNotImplementedMoreThanOnce$2",
+            "desc": "(Ljava/util/Map;Ljava/util/Map$Entry;)Z",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInterfacesNotImplementedMoreThanOnce$1",
+            "desc": "(Ljava/util/Map$Entry;)Lgraphql/language/ImplementingTypeDefinition;",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkInterfacesNotImplementedMoreThanOnce$0",
+            "desc": "(Ljava/util/Map$Entry;)Z",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkImplementingTypes$0",
+            "desc": "(Ljava/util/List;Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/language/ImplementingTypeDefinition;)V",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.EchoingWiringFactory$1": {
+        "line": {
+          "covered": 1,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "serialize",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "parseValue",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 113,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "parseLiteral",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 118,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.SchemaGeneratorAppliedDirectiveHelper": {
+        "line": {
+          "covered": 140,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 47,
+          "missed": 9
+        },
+        "method": {
+          "covered": 18,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "buildAppliedDirectives",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/schema/GraphqlDirectivesContainerTypeBuilder;Lgraphql/util/Pair;)V",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildAppliedDirectives",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Ljava/util/function/Function;Ljava/util/List;Ljava/util/List;Lgraphql/introspection/Introspection$DirectiveLocation;Ljava/util/Set;Lgraphql/schema/GraphqlTypeComparatorRegistry;)Lgraphql/util/Pair;",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildAppliedDirective",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Ljava/util/function/Function;Lgraphql/language/Directive;Ljava/util/Set;Lgraphql/introspection/Introspection$DirectiveLocation;Lgraphql/schema/GraphqlTypeComparatorRegistry;)Lgraphql/util/Pair;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 25,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildDirectiveArg",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/Argument;Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLArgument;",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildAppliedArg",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/Argument;Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLAppliedDirectiveArgument;",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 4
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transferMissingArguments",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Ljava/util/List;Lgraphql/schema/GraphQLDirective;)Ljava/util/List;",
+            "line": 182,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 9,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transferMissingAppliedArguments",
+            "desc": "(Ljava/util/List;Lgraphql/schema/GraphQLDirective;)Ljava/util/List;",
+            "line": 206,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildDirectiveDefinitionFromAst",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/DirectiveDefinition;Ljava/util/function/Function;)Lgraphql/schema/GraphQLDirective;",
+            "line": 230,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildLocations",
+            "desc": "(Lgraphql/language/DirectiveDefinition;)Ljava/util/List;",
+            "line": 247,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildDirectiveArgumentDefinitionFromAst",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/InputValueDefinition;Ljava/util/function/Function;)Lgraphql/schema/GraphQLArgument;",
+            "line": 252,
+            "counters": {
+              "line": {
+                "covered": 18,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildDeprecationReason",
+            "desc": "(Ljava/util/List;)Ljava/lang/String;",
+            "line": 281,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildDeprecationReason$1",
+            "desc": "(Lgraphql/language/Argument;)Ljava/lang/String;",
+            "line": 285,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildDeprecationReason$0",
+            "desc": "(Lgraphql/language/Directive;)Z",
+            "line": 282,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildLocations$0",
+            "desc": "(Lgraphql/language/DirectiveLocation;)Lgraphql/introspection/Introspection$DirectiveLocation;",
+            "line": 248,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildDirectiveDefinitionFromAst$1",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Ljava/util/function/Function;Lgraphql/language/InputValueDefinition;)Lgraphql/schema/GraphQLArgument;",
+            "line": 241,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildDirectiveDefinitionFromAst$0",
+            "desc": "(Lgraphql/schema/GraphQLDirective$Builder;Lgraphql/introspection/Introspection$DirectiveLocation;)V",
+            "line": 238,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildAppliedDirective$1",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/language/Directive;Ljava/util/function/Function;)Lgraphql/schema/GraphQLDirective;",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildAppliedDirective$0",
+            "desc": "(Lgraphql/language/Directive;Lgraphql/schema/GraphQLDirective;)Z",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.ScalarWiringEnvironment": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/language/ScalarTypeDefinition;Ljava/util/List;)V",
+            "line": 18,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getScalarTypeDefinition",
+            "desc": "()Lgraphql/language/ScalarTypeDefinition;",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExtensions",
+            "desc": "()Ljava/util/List;",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.TypeInfo": {
+        "line": {
+          "covered": 51,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 27,
+          "missed": 5
+        },
+        "method": {
+          "covered": 14,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "typeInfo",
+            "desc": "(Lgraphql/language/Type;)Lgraphql/schema/idl/TypeInfo;",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Type;)V",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getRawType",
+            "desc": "()Lgraphql/language/Type;",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeName",
+            "desc": "()Lgraphql/language/TypeName;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isList",
+            "desc": "()Z",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isNonNull",
+            "desc": "()Z",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isPlain",
+            "desc": "()Z",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 4
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "renameAs",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/idl/TypeInfo;",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "decorate",
+            "desc": "(Lgraphql/schema/GraphQLType;)Lgraphql/schema/GraphQLType;",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAstDesc",
+            "desc": "(Lgraphql/language/Type;)Ljava/lang/String;",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unwrapOne",
+            "desc": "()Lgraphql/schema/idl/TypeInfo;",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unwrapOneType",
+            "desc": "()Lgraphql/language/Type;",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeName",
+            "desc": "(Lgraphql/language/Type;)Lgraphql/language/TypeName;",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "typeName",
+            "desc": "(Lgraphql/language/Type;)Ljava/lang/String;",
+            "line": 169,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 193,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.SchemaPrinter$Options": {
+        "line": {
+          "covered": 43,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 29,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(ZZZZLjava/util/function/Predicate;ZZLjava/util/function/Predicate;Ljava/util/function/Predicate;Lgraphql/schema/GraphqlTypeComparatorRegistry;Z)V",
+            "line": 124,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isIncludeIntrospectionTypes",
+            "desc": "()Z",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isIncludeScalars",
+            "desc": "()Z",
+            "line": 143,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isIncludeSchemaDefinition",
+            "desc": "()Z",
+            "line": 147,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isIncludeDirectiveDefinitions",
+            "desc": "()Z",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getIncludeDirectiveDefinition",
+            "desc": "()Ljava/util/function/Predicate;",
+            "line": 155,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getIncludeDirective",
+            "desc": "()Ljava/util/function/Predicate;",
+            "line": 159,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getIncludeSchemaElement",
+            "desc": "()Ljava/util/function/Predicate;",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isDescriptionsAsHashComments",
+            "desc": "()Z",
+            "line": 167,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getComparatorRegistry",
+            "desc": "()Lgraphql/schema/GraphqlTypeComparatorRegistry;",
+            "line": 171,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isUseAstDefinitions",
+            "desc": "()Z",
+            "line": 175,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isIncludeAstDefinitionComments",
+            "desc": "()Z",
+            "line": 179,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "defaultOptions",
+            "desc": "()Lgraphql/schema/idl/SchemaPrinter$Options;",
+            "line": 183,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "includeIntrospectionTypes",
+            "desc": "(Z)Lgraphql/schema/idl/SchemaPrinter$Options;",
+            "line": 203,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "includeScalarTypes",
+            "desc": "(Z)Lgraphql/schema/idl/SchemaPrinter$Options;",
+            "line": 223,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "includeSchemaDefinition",
+            "desc": "(Z)Lgraphql/schema/idl/SchemaPrinter$Options;",
+            "line": 246,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "includeDirectiveDefinitions",
+            "desc": "(Z)Lgraphql/schema/idl/SchemaPrinter$Options;",
+            "line": 272,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "includeDirectiveDefinition",
+            "desc": "(Ljava/util/function/Predicate;)Lgraphql/schema/idl/SchemaPrinter$Options;",
+            "line": 294,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "includeDirectives",
+            "desc": "(Z)Lgraphql/schema/idl/SchemaPrinter$Options;",
+            "line": 316,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "includeDirectives",
+            "desc": "(Ljava/util/function/Predicate;)Lgraphql/schema/idl/SchemaPrinter$Options;",
+            "line": 337,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "includeSchemaElement",
+            "desc": "(Ljava/util/function/Predicate;)Lgraphql/schema/idl/SchemaPrinter$Options;",
+            "line": 359,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "useAstDefinitions",
+            "desc": "(Z)Lgraphql/schema/idl/SchemaPrinter$Options;",
+            "line": 382,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "descriptionsAsHashComments",
+            "desc": "(Z)Lgraphql/schema/idl/SchemaPrinter$Options;",
+            "line": 406,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setComparators",
+            "desc": "(Lgraphql/schema/GraphqlTypeComparatorRegistry;)Lgraphql/schema/idl/SchemaPrinter$Options;",
+            "line": 429,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "includeAstDefinitionComments",
+            "desc": "(Z)Lgraphql/schema/idl/SchemaPrinter$Options;",
+            "line": 452,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$includeDirectives$0",
+            "desc": "(ZLjava/lang/String;)Z",
+            "line": 323,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$includeDirectiveDefinitions$0",
+            "desc": "(ZLjava/lang/String;)Z",
+            "line": 276,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$defaultOptions$2",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;)Z",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$defaultOptions$1",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 189,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$defaultOptions$0",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 187,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.FieldWiringEnvironment": {
+        "line": {
+          "covered": 10,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/language/TypeDefinition;Lgraphql/language/FieldDefinition;Lgraphql/schema/GraphQLOutputType;Ljava/util/List;Ljava/util/List;)V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinition",
+            "desc": "()Lgraphql/language/FieldDefinition;",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParentType",
+            "desc": "()Lgraphql/language/TypeDefinition;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldType",
+            "desc": "()Lgraphql/schema/GraphQLOutputType;",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.ImmutableTypeDefinitionRegistry": {
+        "line": {
+          "covered": 28,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 17,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;)V",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unsupportedOperationException",
+            "desc": "()Ljava/lang/UnsupportedOperationException;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "merge",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;)Lgraphql/schema/idl/TypeDefinitionRegistry;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addAll",
+            "desc": "(Ljava/util/Collection;)Ljava/util/Optional;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "add",
+            "desc": "(Lgraphql/language/SDLDefinition;)Ljava/util/Optional;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "remove",
+            "desc": "(Lgraphql/language/SDLDefinition;)V",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "remove",
+            "desc": "(Ljava/lang/String;Lgraphql/language/SDLDefinition;)V",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "types",
+            "desc": "()Ljava/util/Map;",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "scalars",
+            "desc": "()Ljava/util/Map;",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "objectTypeExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 97,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "interfaceTypeExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unionTypeExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enumTypeExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "scalarTypeExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inputObjectTypeExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 122,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSchemaExtensionDefinitions",
+            "desc": "()Ljava/util/List;",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectiveDefinitions",
+            "desc": "()Ljava/util/Map;",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.SchemaDirectiveWiringSchemaGeneratorPostProcessing": {
+        "line": {
+          "covered": 16,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/schema/idl/RuntimeWiring;Lgraphql/schema/GraphQLCodeRegistry$Builder;)V",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "process",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Lgraphql/schema/GraphQLSchema;",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$process$0",
+            "desc": "(Lgraphql/schema/GraphQLSchema$Builder;)V",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.WiringFactory": {
+        "line": {
+          "covered": 5,
+          "missed": 8
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 8
+        },
+        "methods": [
+          {
+            "name": "providesScalar",
+            "desc": "(Lgraphql/schema/idl/ScalarWiringEnvironment;)Z",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getScalar",
+            "desc": "(Lgraphql/schema/idl/ScalarWiringEnvironment;)Lgraphql/schema/GraphQLScalarType;",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "providesTypeResolver",
+            "desc": "(Lgraphql/schema/idl/InterfaceWiringEnvironment;)Z",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getTypeResolver",
+            "desc": "(Lgraphql/schema/idl/InterfaceWiringEnvironment;)Lgraphql/schema/TypeResolver;",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "providesTypeResolver",
+            "desc": "(Lgraphql/schema/idl/UnionWiringEnvironment;)Z",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getTypeResolver",
+            "desc": "(Lgraphql/schema/idl/UnionWiringEnvironment;)Lgraphql/schema/TypeResolver;",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "providesDataFetcherFactory",
+            "desc": "(Lgraphql/schema/idl/FieldWiringEnvironment;)Z",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDataFetcherFactory",
+            "desc": "(Lgraphql/schema/idl/FieldWiringEnvironment;)Lgraphql/schema/DataFetcherFactory;",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "providesSchemaDirectiveWiring",
+            "desc": "(Lgraphql/schema/idl/SchemaDirectiveWiringEnvironment;)Z",
+            "line": 119,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSchemaDirectiveWiring",
+            "desc": "(Lgraphql/schema/idl/SchemaDirectiveWiringEnvironment;)Lgraphql/schema/idl/SchemaDirectiveWiring;",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "providesDataFetcher",
+            "desc": "(Lgraphql/schema/idl/FieldWiringEnvironment;)Z",
+            "line": 142,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDataFetcher",
+            "desc": "(Lgraphql/schema/idl/FieldWiringEnvironment;)Lgraphql/schema/DataFetcher;",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDefaultDataFetcher",
+            "desc": "(Lgraphql/schema/idl/FieldWiringEnvironment;)Lgraphql/schema/DataFetcher;",
+            "line": 165,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.UnExecutableSchemaGenerator": {
+        "line": {
+          "covered": 8,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 12,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "makeUnExecutableSchema",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;)Lgraphql/schema/GraphQLSchema;",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$makeUnExecutableSchema$0",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/schema/idl/RuntimeWiring$Builder;)V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$makeUnExecutableSchema$1",
+            "desc": "(Lgraphql/schema/idl/RuntimeWiring$Builder;Ljava/lang/String;Lgraphql/language/ScalarTypeDefinition;)V",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.SchemaGenerator": {
+        "line": {
+          "covered": 42,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 6,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createdMockedSchema",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLSchema;",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "makeExecutableSchema",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/schema/idl/RuntimeWiring;)Lgraphql/schema/GraphQLSchema;",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "makeExecutableSchema",
+            "desc": "(Lgraphql/schema/idl/SchemaGenerator$Options;Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/schema/idl/RuntimeWiring;)Lgraphql/schema/GraphQLSchema;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "makeExecutableSchemaImpl",
+            "desc": "(Lgraphql/schema/idl/ImmutableTypeDefinitionRegistry;Lgraphql/schema/idl/RuntimeWiring;Ljava/util/Map;Lgraphql/schema/idl/SchemaGenerator$Options;)Lgraphql/schema/GraphQLSchema;",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 20,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$makeExecutableSchemaImpl$0",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/schema/GraphQLSchema$Builder;Lgraphql/language/SchemaDefinition;)V",
+            "line": 147,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.SchemaGenerator$Options": {
+        "line": {
+          "covered": 15,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 10,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(ZZZ)V",
+            "line": 177,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(ZZZZ)V",
+            "line": 181,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isUseCommentsAsDescription",
+            "desc": "()Z",
+            "line": 189,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isCaptureAstDefinitions",
+            "desc": "()Z",
+            "line": 193,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isUseAppliedDirectivesOnly",
+            "desc": "()Z",
+            "line": 197,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isWithValidation",
+            "desc": "()Z",
+            "line": 202,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "defaultOptions",
+            "desc": "()Lgraphql/schema/idl/SchemaGenerator$Options;",
+            "line": 206,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "useCommentsAsDescriptions",
+            "desc": "(Z)Lgraphql/schema/idl/SchemaGenerator$Options;",
+            "line": 219,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "captureAstDefinitions",
+            "desc": "(Z)Lgraphql/schema/idl/SchemaGenerator$Options;",
+            "line": 231,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "useAppliedDirectivesOnly",
+            "desc": "(Z)Lgraphql/schema/idl/SchemaGenerator$Options;",
+            "line": 244,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withValidation",
+            "desc": "(Z)Lgraphql/schema/idl/SchemaGenerator$Options;",
+            "line": 260,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.UnionWiringEnvironment": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/language/UnionTypeDefinition;)V",
+            "line": 14,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getUnionTypeDefinition",
+            "desc": "()Lgraphql/language/UnionTypeDefinition;",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.SchemaGeneratorDirectiveHelper": {
+        "line": {
+          "covered": 150,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 32,
+          "missed": 4
+        },
+        "method": {
+          "covered": 35,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "schemaDirectiveWiringIsRequired",
+            "desc": "(Lgraphql/schema/GraphQLDirectiveContainer;Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/schema/idl/RuntimeWiring;)Z",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildAstTree",
+            "desc": "([Lgraphql/language/NamedNode;)Lgraphql/language/NodeParentTree;",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildRuntimeTree",
+            "desc": "([Lgraphql/schema/GraphQLSchemaElement;)Lgraphql/schema/GraphqlElementParentTree;",
+            "line": 154,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "wireArguments",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/GraphQLFieldsContainer;Lgraphql/language/NamedNode;Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;Lgraphql/schema/GraphQLFieldDefinition;)Ljava/util/List;",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "wireFields",
+            "desc": "(Lgraphql/schema/GraphQLFieldsContainer;Lgraphql/language/NamedNode;Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;)Ljava/util/List;",
+            "line": 174,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onObject",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 196,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onInterface",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;)Lgraphql/schema/GraphQLInterfaceType;",
+            "line": 221,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onEnum",
+            "desc": "(Lgraphql/schema/GraphQLEnumType;Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;)Lgraphql/schema/GraphQLEnumType;",
+            "line": 248,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onInputObjectType",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;)Lgraphql/schema/GraphQLInputObjectType;",
+            "line": 282,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onUnion",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;)Lgraphql/schema/GraphQLUnionType;",
+            "line": 316,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onScalar",
+            "desc": "(Lgraphql/schema/GraphQLScalarType;Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;)Lgraphql/schema/GraphQLScalarType;",
+            "line": 334,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onField",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 352,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onInputObjectField",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;)Lgraphql/schema/GraphQLInputObjectField;",
+            "line": 366,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onEnumValue",
+            "desc": "(Lgraphql/schema/GraphQLEnumValueDefinition;Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;)Lgraphql/schema/GraphQLEnumValueDefinition;",
+            "line": 380,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onArgument",
+            "desc": "(Lgraphql/schema/GraphQLArgument;Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;)Lgraphql/schema/GraphQLArgument;",
+            "line": 394,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "wireDirectives",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;Lgraphql/schema/GraphQLDirectiveContainer;Ljava/util/List;Ljava/util/List;Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$EnvBuilder;Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$EnvInvoker;)Lgraphql/schema/GraphQLDirectiveContainer;",
+            "line": 429,
+            "counters": {
+              "line": {
+                "covered": 21,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "invokeWiring",
+            "desc": "(Lgraphql/schema/GraphQLDirectiveContainer;Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$EnvInvoker;Lgraphql/schema/idl/SchemaDirectiveWiring;Lgraphql/schema/idl/SchemaDirectiveWiringEnvironment;)Lgraphql/schema/GraphQLDirectiveContainer;",
+            "line": 466,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isNotTheSameObjects",
+            "desc": "(Ljava/util/List;Ljava/util/List;)Z",
+            "line": 472,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$onArgument$0",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;Lgraphql/schema/GraphQLArgument;Ljava/util/List;Ljava/util/List;Lgraphql/schema/GraphQLAppliedDirective;Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/idl/SchemaDirectiveWiringEnvironment;",
+            "line": 398,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$onEnumValue$0",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;Lgraphql/schema/GraphQLEnumValueDefinition;Ljava/util/List;Ljava/util/List;Lgraphql/schema/GraphQLAppliedDirective;Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/idl/SchemaDirectiveWiringEnvironment;",
+            "line": 384,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$onInputObjectField$0",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;Lgraphql/schema/GraphQLInputObjectField;Ljava/util/List;Ljava/util/List;Lgraphql/schema/GraphQLAppliedDirective;Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/idl/SchemaDirectiveWiringEnvironment;",
+            "line": 370,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$onField$0",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;Lgraphql/schema/GraphQLFieldDefinition;Ljava/util/List;Ljava/util/List;Lgraphql/schema/GraphQLAppliedDirective;Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/idl/SchemaDirectiveWiringEnvironment;",
+            "line": 356,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$onScalar$0",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;Lgraphql/schema/GraphQLScalarType;Ljava/util/List;Ljava/util/List;Lgraphql/schema/GraphQLAppliedDirective;Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/idl/SchemaDirectiveWiringEnvironment;",
+            "line": 342,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$onUnion$0",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;Lgraphql/schema/GraphQLUnionType;Ljava/util/List;Ljava/util/List;Lgraphql/schema/GraphQLAppliedDirective;Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/idl/SchemaDirectiveWiringEnvironment;",
+            "line": 324,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$onInputObjectType$2",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;Lgraphql/schema/GraphQLInputObjectType;Ljava/util/List;Ljava/util/List;Lgraphql/schema/GraphQLAppliedDirective;Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/idl/SchemaDirectiveWiringEnvironment;",
+            "line": 305,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$onInputObjectType$1",
+            "desc": "(Ljava/util/List;Lgraphql/schema/GraphQLInputObjectType$Builder;)V",
+            "line": 294,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$onInputObjectType$0",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;Lgraphql/schema/GraphQLInputObjectField;)Lgraphql/schema/GraphQLInputObjectField;",
+            "line": 285,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$onEnum$2",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;Lgraphql/schema/GraphQLEnumType;Ljava/util/List;Ljava/util/List;Lgraphql/schema/GraphQLAppliedDirective;Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/idl/SchemaDirectiveWiringEnvironment;",
+            "line": 272,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$onEnum$1",
+            "desc": "(Ljava/util/List;Lgraphql/schema/GraphQLEnumType$Builder;)V",
+            "line": 261,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$onEnum$0",
+            "desc": "(Lgraphql/schema/GraphQLEnumType;Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;Lgraphql/schema/GraphQLEnumValueDefinition;)Lgraphql/schema/GraphQLEnumValueDefinition;",
+            "line": 251,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$onInterface$1",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;Lgraphql/schema/GraphQLInterfaceType;Ljava/util/List;Ljava/util/List;Lgraphql/schema/GraphQLAppliedDirective;Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/idl/SchemaDirectiveWiringEnvironment;",
+            "line": 237,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$onInterface$0",
+            "desc": "(Ljava/util/List;Lgraphql/schema/GraphQLInterfaceType$Builder;)V",
+            "line": 226,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$onObject$1",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;Lgraphql/schema/GraphQLObjectType;Ljava/util/List;Ljava/util/List;Lgraphql/schema/GraphQLAppliedDirective;Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/idl/SchemaDirectiveWiringEnvironment;",
+            "line": 211,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$onObject$0",
+            "desc": "(Ljava/util/List;Lgraphql/schema/GraphQLObjectType$Builder;)V",
+            "line": 201,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$wireFields$0",
+            "desc": "(Lgraphql/schema/GraphQLFieldsContainer;Lgraphql/language/NamedNode;Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;Lgraphql/schema/GraphQLFieldDefinition;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 177,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$wireFields$1",
+            "desc": "(Ljava/util/List;Lgraphql/schema/GraphQLFieldDefinition$Builder;)V",
+            "line": 182,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$wireArguments$0",
+            "desc": "(Lgraphql/language/NamedNode;Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/GraphQLFieldsContainer;Lgraphql/schema/idl/SchemaGeneratorDirectiveHelper$Parameters;Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/GraphQLArgument;)Lgraphql/schema/GraphQLArgument;",
+            "line": 164,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.NoopWiringFactory": {
+        "line": {
+          "covered": 6,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 11,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "providesScalar",
+            "desc": "(Lgraphql/schema/idl/ScalarWiringEnvironment;)Z",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getScalar",
+            "desc": "(Lgraphql/schema/idl/ScalarWiringEnvironment;)Lgraphql/schema/GraphQLScalarType;",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "providesTypeResolver",
+            "desc": "(Lgraphql/schema/idl/InterfaceWiringEnvironment;)Z",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeResolver",
+            "desc": "(Lgraphql/schema/idl/InterfaceWiringEnvironment;)Lgraphql/schema/TypeResolver;",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "providesTypeResolver",
+            "desc": "(Lgraphql/schema/idl/UnionWiringEnvironment;)Z",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeResolver",
+            "desc": "(Lgraphql/schema/idl/UnionWiringEnvironment;)Lgraphql/schema/TypeResolver;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "providesDataFetcher",
+            "desc": "(Lgraphql/schema/idl/FieldWiringEnvironment;)Z",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDataFetcher",
+            "desc": "(Lgraphql/schema/idl/FieldWiringEnvironment;)Lgraphql/schema/DataFetcher;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDefaultDataFetcher",
+            "desc": "(Lgraphql/schema/idl/FieldWiringEnvironment;)Lgraphql/schema/DataFetcher;",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.ArgValueOfAllowedTypeChecker": {
+        "line": {
+          "covered": 114,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 46,
+          "missed": 4
+        },
+        "method": {
+          "covered": 21,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Directive;Lgraphql/language/Node;Ljava/lang/String;Lgraphql/language/Argument;Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/schema/idl/RuntimeWiring;)V",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkArgValueMatchesAllowedType",
+            "desc": "(Ljava/util/List;Lgraphql/language/Value;Lgraphql/language/Type;)V",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addValidationError",
+            "desc": "(Ljava/util/List;Ljava/lang/String;[Ljava/lang/Object;)V",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkArgValueMatchesAllowedTypeName",
+            "desc": "(Ljava/util/List;Lgraphql/language/Value;Lgraphql/language/Type;)V",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkArgValueMatchesAllowedInputType",
+            "desc": "(Ljava/util/List;Lgraphql/language/Value;Lgraphql/language/InputObjectTypeDefinition;)V",
+            "line": 142,
+            "counters": {
+              "line": {
+                "covered": 32,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkArgValueMatchesAllowedEnum",
+            "desc": "(Ljava/util/List;Lgraphql/language/Value;Lgraphql/language/EnumTypeDefinition;)V",
+            "line": 196,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkArgValueMatchesAllowedScalar",
+            "desc": "(Ljava/util/List;Lgraphql/language/Value;Lgraphql/language/ScalarTypeDefinition;)V",
+            "line": 219,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkArgInputObjectValueFieldMatchesAllowedDefinition",
+            "desc": "(Ljava/util/List;Lgraphql/language/ObjectField;Lgraphql/language/InputValueDefinition;)V",
+            "line": 238,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkArgValueMatchesAllowedNonNullType",
+            "desc": "(Ljava/util/List;Lgraphql/language/Value;Lgraphql/language/NonNullType;)V",
+            "line": 254,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkArgValueMatchesAllowedListType",
+            "desc": "(Ljava/util/List;Lgraphql/language/Value;Lgraphql/language/ListType;)V",
+            "line": 270,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isArgumentValueScalarLiteral",
+            "desc": "(Lgraphql/schema/GraphQLScalarType;Lgraphql/language/Value;)Z",
+            "line": 288,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkArgValueMatchesAllowedListType$0",
+            "desc": "(Ljava/util/List;Lgraphql/language/Type;Lgraphql/language/Value;)V",
+            "line": 282,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkArgValueMatchesAllowedEnum$1",
+            "desc": "(Lgraphql/language/EnumValue;Lgraphql/language/EnumValueDefinition;)Z",
+            "line": 208,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkArgValueMatchesAllowedEnum$0",
+            "desc": "(Lgraphql/language/EnumTypeExtensionDefinition;)Ljava/util/stream/Stream;",
+            "line": 204,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkArgValueMatchesAllowedInputType$6",
+            "desc": "(Ljava/util/Map;Ljava/util/List;Lgraphql/language/InputValueDefinition;)V",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkArgValueMatchesAllowedInputType$5",
+            "desc": "(Lgraphql/language/ObjectField;)Lgraphql/language/ObjectField;",
+            "line": 187,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkArgValueMatchesAllowedInputType$4",
+            "desc": "(Ljava/util/Map;Lgraphql/language/ObjectField;)Z",
+            "line": 173,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkArgValueMatchesAllowedInputType$3",
+            "desc": "(Lgraphql/language/InputValueDefinition;)Lgraphql/language/InputValueDefinition;",
+            "line": 170,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkArgValueMatchesAllowedInputType$2",
+            "desc": "(Ljava/util/Map$Entry;)Z",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkArgValueMatchesAllowedInputType$1",
+            "desc": "(Ljava/lang/Long;)Z",
+            "line": 160,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkArgValueMatchesAllowedInputType$0",
+            "desc": "(Lgraphql/language/InputObjectTypeExtensionDefinition;)Ljava/util/stream/Stream;",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.SchemaPrinter": {
+        "line": {
+          "covered": 530,
+          "missed": 19
+        },
+        "branch": {
+          "covered": 241,
+          "missed": 35
+        },
+        "method": {
+          "covered": 77,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 471,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/idl/SchemaPrinter$Options;)V",
+            "line": 466,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "print",
+            "desc": "(Lgraphql/language/Document;)Ljava/lang/String;",
+            "line": 497,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "print",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Ljava/lang/String;",
+            "line": 509,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isIntrospectionType",
+            "desc": "(Lgraphql/schema/GraphQLNamedType;)Z",
+            "line": 541,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "scalarPrinter",
+            "desc": "()Lgraphql/schema/idl/SchemaPrinter$SchemaElementPrinter;",
+            "line": 545,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enumPrinter",
+            "desc": "()Lgraphql/schema/idl/SchemaPrinter$SchemaElementPrinter;",
+            "line": 577,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printFieldDefinitions",
+            "desc": "(Ljava/io/PrintWriter;Ljava/util/Comparator;Ljava/util/List;)V",
+            "line": 607,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "interfacePrinter",
+            "desc": "()Lgraphql/schema/idl/SchemaPrinter$SchemaElementPrinter;",
+            "line": 627,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unionPrinter",
+            "desc": "()Lgraphql/schema/idl/SchemaPrinter$SchemaElementPrinter;",
+            "line": 661,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directivePrinter",
+            "desc": "()Lgraphql/schema/idl/SchemaPrinter$SchemaElementPrinter;",
+            "line": 690,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "objectPrinter",
+            "desc": "()Lgraphql/schema/idl/SchemaPrinter$SchemaElementPrinter;",
+            "line": 702,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inputObjectPrinter",
+            "desc": "()Lgraphql/schema/idl/SchemaPrinter$SchemaElementPrinter;",
+            "line": 735,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "shouldPrintAsAst",
+            "desc": "(Lgraphql/language/TypeDefinition;)Z",
+            "line": 781,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "shouldPrintAsAst",
+            "desc": "(Lgraphql/language/SchemaDefinition;)Z",
+            "line": 792,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printAsAst",
+            "desc": "(Ljava/io/PrintWriter;Lgraphql/language/TypeDefinition;Ljava/util/List;)V",
+            "line": 805,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printAsAst",
+            "desc": "(Ljava/io/PrintWriter;Lgraphql/language/SchemaDefinition;Ljava/util/List;)V",
+            "line": 823,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printAst",
+            "desc": "(Lgraphql/schema/InputValueWithState;Lgraphql/schema/GraphQLInputType;)Ljava/lang/String;",
+            "line": 834,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "schemaPrinter",
+            "desc": "()Lgraphql/schema/idl/SchemaPrinter$SchemaElementPrinter;",
+            "line": 838,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSchemaDirectives",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Ljava/util/List;",
+            "line": 884,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "typeString",
+            "desc": "(Lgraphql/schema/GraphQLType;)Ljava/lang/String;",
+            "line": 892,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "argsString",
+            "desc": "(Ljava/util/List;)Ljava/lang/String;",
+            "line": 896,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "argsString",
+            "desc": "(Ljava/lang/Class;Ljava/util/List;)Ljava/lang/String;",
+            "line": 900,
+            "counters": {
+              "line": {
+                "covered": 34,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 28,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directivesString",
+            "desc": "(Ljava/lang/Class;Lgraphql/schema/GraphQLDirectiveContainer;)Ljava/lang/String;",
+            "line": 949,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directivesString",
+            "desc": "(Ljava/lang/Class;ZLgraphql/schema/GraphQLDirectiveContainer;)Ljava/lang/String;",
+            "line": 954,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directivesString",
+            "desc": "(Ljava/lang/Class;Ljava/util/List;)Ljava/lang/String;",
+            "line": 963,
+            "counters": {
+              "line": {
+                "covered": 20,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directiveString",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirective;)Ljava/lang/String;",
+            "line": 994,
+            "counters": {
+              "line": {
+                "covered": 26,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 4
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isDeprecatedDirectiveAllowed",
+            "desc": "()Z",
+            "line": 1038,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isDeprecatedDirective",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirective;)Z",
+            "line": 1042,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasDeprecatedDirective",
+            "desc": "(Ljava/util/List;)Z",
+            "line": 1046,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addOrUpdateDeprecatedDirectiveIfNeeded",
+            "desc": "(Lgraphql/schema/GraphQLDirectiveContainer;)Ljava/util/List;",
+            "line": 1052,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createDeprecatedDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLAppliedDirective;",
+            "line": 1066,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "updateDeprecatedDirective",
+            "desc": "(Ljava/util/List;Ljava/lang/String;)Ljava/util/List;",
+            "line": 1078,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDeprecationReason",
+            "desc": "(Lgraphql/schema/GraphQLDirectiveContainer;)Ljava/lang/String;",
+            "line": 1096,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "specifiedByUrlString",
+            "desc": "(Lgraphql/schema/GraphQLScalarType;)Ljava/lang/String;",
+            "line": 1114,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directiveDefinition",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)Ljava/lang/String;",
+            "line": 1122,
+            "counters": {
+              "line": {
+                "covered": 19,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printer",
+            "desc": "(Ljava/lang/Class;)Lgraphql/schema/idl/SchemaPrinter$SchemaElementPrinter;",
+            "line": 1157,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 5
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "print",
+            "desc": "(Lgraphql/schema/GraphQLType;)Ljava/lang/String;",
+            "line": 1172,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "print",
+            "desc": "(Ljava/util/List;)Ljava/lang/String;",
+            "line": 1181,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "print",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)Ljava/lang/String;",
+            "line": 1197,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printSchemaElement",
+            "desc": "(Ljava/io/PrintWriter;Lgraphql/schema/GraphQLSchemaElement;Lgraphql/schema/visibility/GraphqlFieldVisibility;)V",
+            "line": 1201,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printComments",
+            "desc": "(Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/String;",
+            "line": 1206,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printComments",
+            "desc": "(Ljava/io/PrintWriter;Ljava/lang/Object;Ljava/lang/String;)V",
+            "line": 1213,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 13,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printMultiLineHashDescription",
+            "desc": "(Ljava/io/PrintWriter;Ljava/lang/String;Ljava/util/List;)V",
+            "line": 1239,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printMultiLineDescription",
+            "desc": "(Ljava/io/PrintWriter;Ljava/lang/String;Ljava/util/List;)V",
+            "line": 1243,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printSingleLineDescription",
+            "desc": "(Ljava/io/PrintWriter;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 1253,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasAstDefinitionComments",
+            "desc": "(Ljava/lang/Object;)Z",
+            "line": 1258,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAstDefinitionComments",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/String;",
+            "line": 1263,
+            "counters": {
+              "line": {
+                "covered": 36,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 23,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comments",
+            "desc": "(Ljava/util/List;)Ljava/lang/String;",
+            "line": 1305,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasDescription",
+            "desc": "(Ljava/lang/Object;)Z",
+            "line": 1313,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDescription",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/String;",
+            "line": 1318,
+            "counters": {
+              "line": {
+                "covered": 36,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 23,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Description;)Ljava/lang/String;",
+            "line": 1364,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getComparator",
+            "desc": "(Ljava/lang/Class;Ljava/lang/Class;)Ljava/util/Comparator;",
+            "line": 1374,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "trimNewLineChars",
+            "desc": "(Ljava/lang/String;)Ljava/lang/String;",
+            "line": 1382,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isNullOrEmpty",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 1389,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$comments$0",
+            "desc": "(Lgraphql/language/Comment;)Ljava/lang/String;",
+            "line": 1308,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$printMultiLineDescription$0",
+            "desc": "(Ljava/io/PrintWriter;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 1245,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$printMultiLineHashDescription$0",
+            "desc": "(Ljava/io/PrintWriter;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 1239,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$printer$0",
+            "desc": "(Ljava/io/PrintWriter;Ljava/lang/Object;Lgraphql/schema/visibility/GraphqlFieldVisibility;)V",
+            "line": 1163,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$updateDeprecatedDirective$0",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirectiveArgument;Lgraphql/schema/GraphQLAppliedDirective;)Lgraphql/schema/GraphQLAppliedDirective;",
+            "line": 1085,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$updateDeprecatedDirective$1",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirectiveArgument;Lgraphql/schema/GraphQLAppliedDirective$Builder;)V",
+            "line": 1088,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$directiveString$0",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirectiveArgument;)Z",
+            "line": 1009,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$directivesString$0",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirective;)Z",
+            "line": 965,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getSchemaDirectives$0",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)Z",
+            "line": 884,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$schemaPrinter$0",
+            "desc": "(Ljava/io/PrintWriter;Lgraphql/schema/GraphQLSchema;Lgraphql/schema/visibility/GraphqlFieldVisibility;)V",
+            "line": 839,
+            "counters": {
+              "line": {
+                "covered": 25,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 25,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$inputObjectPrinter$0",
+            "desc": "(Ljava/io/PrintWriter;Lgraphql/schema/GraphQLInputObjectType;Lgraphql/schema/visibility/GraphqlFieldVisibility;)V",
+            "line": 736,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$inputObjectPrinter$1",
+            "desc": "(Ljava/io/PrintWriter;Lgraphql/schema/GraphQLInputObjectField;)V",
+            "line": 755,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$objectPrinter$0",
+            "desc": "(Ljava/io/PrintWriter;Lgraphql/schema/GraphQLObjectType;Lgraphql/schema/visibility/GraphqlFieldVisibility;)V",
+            "line": 703,
+            "counters": {
+              "line": {
+                "covered": 20,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$directivePrinter$0",
+            "desc": "(Ljava/io/PrintWriter;Lgraphql/schema/GraphQLDirective;Lgraphql/schema/visibility/GraphqlFieldVisibility;)V",
+            "line": 691,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$unionPrinter$0",
+            "desc": "(Ljava/io/PrintWriter;Lgraphql/schema/GraphQLUnionType;Lgraphql/schema/visibility/GraphqlFieldVisibility;)V",
+            "line": 662,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$interfacePrinter$0",
+            "desc": "(Ljava/io/PrintWriter;Lgraphql/schema/GraphQLInterfaceType;Lgraphql/schema/visibility/GraphqlFieldVisibility;)V",
+            "line": 628,
+            "counters": {
+              "line": {
+                "covered": 19,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$printFieldDefinitions$0",
+            "desc": "(Ljava/io/PrintWriter;Lgraphql/schema/GraphQLFieldDefinition;)V",
+            "line": 617,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$enumPrinter$0",
+            "desc": "(Ljava/io/PrintWriter;Lgraphql/schema/GraphQLEnumType;Lgraphql/schema/visibility/GraphqlFieldVisibility;)V",
+            "line": 578,
+            "counters": {
+              "line": {
+                "covered": 20,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$scalarPrinter$0",
+            "desc": "(Ljava/io/PrintWriter;Lgraphql/schema/GraphQLScalarType;Lgraphql/schema/visibility/GraphqlFieldVisibility;)V",
+            "line": 546,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 9,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$scalarPrinter$1",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirective;)Z",
+            "line": 565,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$print$0",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;)Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 522,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$0",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.RuntimeWiring": {
+        "line": {
+          "covered": 45,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 18,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/idl/RuntimeWiring$Builder;)V",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newRuntimeWiring",
+            "desc": "()Lgraphql/schema/idl/RuntimeWiring$Builder;",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newRuntimeWiring",
+            "desc": "(Lgraphql/schema/idl/RuntimeWiring;)Lgraphql/schema/idl/RuntimeWiring$Builder;",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/schema/idl/RuntimeWiring;",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCodeRegistry",
+            "desc": "()Lgraphql/schema/GraphQLCodeRegistry;",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getScalars",
+            "desc": "()Ljava/util/Map;",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDataFetchers",
+            "desc": "()Ljava/util/Map;",
+            "line": 118,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDataFetcherForType",
+            "desc": "(Ljava/lang/String;)Ljava/util/Map;",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDataFetchersForType",
+            "desc": "(Ljava/lang/String;)Ljava/util/Map;",
+            "line": 143,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefaultDataFetcherForType",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/DataFetcher;",
+            "line": 147,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeResolvers",
+            "desc": "()Ljava/util/Map;",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getEnumValuesProviders",
+            "desc": "()Ljava/util/Map;",
+            "line": 155,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getWiringFactory",
+            "desc": "()Lgraphql/schema/idl/WiringFactory;",
+            "line": 159,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldVisibility",
+            "desc": "()Lgraphql/schema/visibility/GraphqlFieldVisibility;",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getRegisteredDirectiveWiring",
+            "desc": "()Ljava/util/Map;",
+            "line": 167,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectiveWiring",
+            "desc": "()Ljava/util/List;",
+            "line": 171,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getComparatorRegistry",
+            "desc": "()Lgraphql/schema/GraphqlTypeComparatorRegistry;",
+            "line": 175,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getDataFetchersForType$0",
+            "desc": "(Ljava/lang/String;)Ljava/util/Map;",
+            "line": 143,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getDataFetcherForType$0",
+            "desc": "(Ljava/lang/String;)Ljava/util/Map;",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.MapEnumValuesProvider": {
+        "line": {
+          "covered": 5,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Map;)V",
+            "line": 14,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getValue",
+            "desc": "(Ljava/lang/String;)Ljava/lang/Object;",
+            "line": 21,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.SchemaParser": {
+        "line": {
+          "covered": 25,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 8,
+          "missed": 0
+        },
+        "method": {
+          "covered": 8,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parse",
+            "desc": "(Ljava/io/File;)Lgraphql/schema/idl/TypeDefinitionRegistry;",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "parse",
+            "desc": "(Ljava/io/InputStream;)Lgraphql/schema/idl/TypeDefinitionRegistry;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "parse",
+            "desc": "(Ljava/io/Reader;)Lgraphql/schema/idl/TypeDefinitionRegistry;",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parse",
+            "desc": "(Ljava/io/Reader;Lgraphql/parser/ParserOptions;)Lgraphql/schema/idl/TypeDefinitionRegistry;",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parse",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/idl/TypeDefinitionRegistry;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseImpl",
+            "desc": "(Ljava/io/Reader;)Lgraphql/schema/idl/TypeDefinitionRegistry;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseImpl",
+            "desc": "(Ljava/io/Reader;Lgraphql/parser/ParserOptions;)Lgraphql/schema/idl/TypeDefinitionRegistry;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleParseException",
+            "desc": "(Lgraphql/InvalidSyntaxError;)Lgraphql/schema/idl/errors/SchemaProblem;",
+            "line": 134,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildRegistry",
+            "desc": "(Lgraphql/language/Document;)Lgraphql/schema/idl/TypeDefinitionRegistry;",
+            "line": 148,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.RuntimeWiring$Builder": {
+        "line": {
+          "covered": 65,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 29,
+          "missed": 1
+        },
+        "method": {
+          "covered": 15,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 181,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "strictMode",
+            "desc": "(Z)Lgraphql/schema/idl/RuntimeWiring$Builder;",
+            "line": 204,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "strictMode",
+            "desc": "()Lgraphql/schema/idl/RuntimeWiring$Builder;",
+            "line": 217,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "wiringFactory",
+            "desc": "(Lgraphql/schema/idl/WiringFactory;)Lgraphql/schema/idl/RuntimeWiring$Builder;",
+            "line": 229,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "codeRegistry",
+            "desc": "(Lgraphql/schema/GraphQLCodeRegistry;)Lgraphql/schema/idl/RuntimeWiring$Builder;",
+            "line": 242,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "codeRegistry",
+            "desc": "(Lgraphql/schema/GraphQLCodeRegistry$Builder;)Lgraphql/schema/idl/RuntimeWiring$Builder;",
+            "line": 254,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "scalar",
+            "desc": "(Lgraphql/schema/GraphQLScalarType;)Lgraphql/schema/idl/RuntimeWiring$Builder;",
+            "line": 266,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldVisibility",
+            "desc": "(Lgraphql/schema/visibility/GraphqlFieldVisibility;)Lgraphql/schema/idl/RuntimeWiring$Builder;",
+            "line": 281,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "type",
+            "desc": "(Lgraphql/schema/idl/TypeRuntimeWiring$Builder;)Lgraphql/schema/idl/RuntimeWiring$Builder;",
+            "line": 293,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "type",
+            "desc": "(Ljava/lang/String;Ljava/util/function/UnaryOperator;)Lgraphql/schema/idl/RuntimeWiring$Builder;",
+            "line": 305,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "type",
+            "desc": "(Lgraphql/schema/idl/TypeRuntimeWiring;)Lgraphql/schema/idl/RuntimeWiring$Builder;",
+            "line": 317,
+            "counters": {
+              "line": {
+                "covered": 25,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 25,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directive",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/idl/SchemaDirectiveWiring;)Lgraphql/schema/idl/RuntimeWiring$Builder;",
+            "line": 377,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directiveWiring",
+            "desc": "(Lgraphql/schema/idl/SchemaDirectiveWiring;)Lgraphql/schema/idl/RuntimeWiring$Builder;",
+            "line": 397,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comparatorRegistry",
+            "desc": "(Lgraphql/schema/GraphqlTypeComparatorRegistry;)Lgraphql/schema/idl/RuntimeWiring$Builder;",
+            "line": 411,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/idl/RuntimeWiring;",
+            "line": 420,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$type$0",
+            "desc": "(Ljava/lang/String;)Ljava/util/Map;",
+            "line": 318,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.MockedWiringFactory$1": {
+        "line": {
+          "covered": 25,
+          "missed": 9
+        },
+        "branch": {
+          "covered": 13,
+          "missed": 7
+        },
+        "method": {
+          "covered": 5,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/idl/MockedWiringFactory;)V",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "serialize",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "parseValue",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "parseLiteral",
+            "desc": "(Lgraphql/language/Value;Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseLiteralImpl",
+            "desc": "(Lgraphql/language/Value;Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 109,
+            "counters": {
+              "line": {
+                "covered": 19,
+                "missed": 7
+              },
+              "branch": {
+                "covered": 12,
+                "missed": 6
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$parseLiteralImpl$1",
+            "desc": "(Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;Ljava/util/Map;Lgraphql/language/ObjectField;)V",
+            "line": 141,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$parseLiteralImpl$0",
+            "desc": "(Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;Lgraphql/language/Value;)Ljava/lang/Object;",
+            "line": 134,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.FastSchemaGenerator": {
+        "line": {
+          "covered": 53,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 11,
+          "missed": 1
+        },
+        "method": {
+          "covered": 8,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "makeExecutableSchema",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/schema/idl/RuntimeWiring;)Lgraphql/schema/GraphQLSchema;",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "makeExecutableSchema",
+            "desc": "(Lgraphql/schema/idl/SchemaGenerator$Options;Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/schema/idl/RuntimeWiring;)Lgraphql/schema/GraphQLSchema;",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "makeExecutableSchemaImpl",
+            "desc": "(Lgraphql/schema/idl/ImmutableTypeDefinitionRegistry;Lgraphql/schema/idl/RuntimeWiring;Ljava/util/Map;Lgraphql/schema/idl/SchemaGenerator$Options;)Lgraphql/schema/GraphQLSchema;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 25,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOperationTypeName",
+            "desc": "(Ljava/util/Map;Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "findOperationType",
+            "desc": "(Ljava/util/Set;Ljava/lang/String;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 158,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$makeExecutableSchemaImpl$1",
+            "desc": "(Lgraphql/schema/idl/SchemaGeneratorHelper$BuildContext;Lgraphql/schema/GraphQLSchema$FastBuilder;Lgraphql/language/SchemaDefinition;)V",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$makeExecutableSchemaImpl$0",
+            "desc": "(Lgraphql/schema/GraphQLType;)Lgraphql/schema/GraphQLNamedType;",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.TypeRuntimeWiring$Builder": {
+        "line": {
+          "covered": 36,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 9,
+          "missed": 1
+        },
+        "method": {
+          "covered": 11,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "typeName",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/idl/TypeRuntimeWiring$Builder;",
+            "line": 119,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "strictMode",
+            "desc": "(Z)Lgraphql/schema/idl/TypeRuntimeWiring$Builder;",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "strictMode",
+            "desc": "()Lgraphql/schema/idl/TypeRuntimeWiring$Builder;",
+            "line": 144,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "dataFetcher",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/DataFetcher;)Lgraphql/schema/idl/TypeRuntimeWiring$Builder;",
+            "line": 157,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "dataFetchers",
+            "desc": "(Ljava/util/Map;)Lgraphql/schema/idl/TypeRuntimeWiring$Builder;",
+            "line": 174,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertFieldStrictly",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 185,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "defaultDataFetcher",
+            "desc": "(Lgraphql/schema/DataFetcher;)Lgraphql/schema/idl/TypeRuntimeWiring$Builder;",
+            "line": 199,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "typeResolver",
+            "desc": "(Lgraphql/schema/TypeResolver;)Lgraphql/schema/idl/TypeRuntimeWiring$Builder;",
+            "line": 216,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enumValues",
+            "desc": "(Lgraphql/schema/idl/EnumValuesProvider;)Lgraphql/schema/idl/TypeRuntimeWiring$Builder;",
+            "line": 222,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/idl/TypeRuntimeWiring;",
+            "line": 231,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$dataFetchers$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/DataFetcher;)V",
+            "line": 177,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.InterfaceWiringEnvironment": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/idl/TypeDefinitionRegistry;Lgraphql/language/InterfaceTypeDefinition;)V",
+            "line": 14,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInterfaceTypeDefinition",
+            "desc": "()Lgraphql/language/InterfaceTypeDefinition;",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.validation.SchemaValidationErrorType": {
+        "line": {
+          "covered": 22,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 5,
+            "counters": {
+              "line": {
+                "covered": 22,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.validation.OneOfInputObjectRules": {
+        "line": {
+          "covered": 37,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 22,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputObjectType",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "canBeProvidedAFiniteValue",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;Ljava/util/Set;)Z",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 18,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 12,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputObjectField",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.validation.InvalidSchemaException": {
+        "line": {
+          "covered": 9,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Collection;)V",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrors",
+            "desc": "()Ljava/util/Collection;",
+            "line": 21,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildErrorMsg",
+            "desc": "(Ljava/util/Collection;)Ljava/lang/String;",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.validation.InputAndOutputTypesUsedAppropriately": {
+        "line": {
+          "covered": 35,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 6,
+          "missed": 0
+        },
+        "method": {
+          "covered": 11,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputObjectField",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkIsAllInputTypes",
+            "desc": "(Lgraphql/schema/GraphQLInputType;Lgraphql/schema/validation/SchemaValidationErrorCollector;Ljava/lang/String;)V",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkIsAllOutputTypes",
+            "desc": "(Lgraphql/schema/GraphQLOutputType;Lgraphql/schema/validation/SchemaValidationErrorCollector;Ljava/lang/String;)V",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkTypeContext",
+            "desc": "(Lgraphql/schema/GraphQLType;Lgraphql/schema/validation/SchemaValidationErrorCollector;Ljava/lang/String;Ljava/util/function/Predicate;Ljava/util/function/BiFunction;)V",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeName",
+            "desc": "(Lgraphql/schema/GraphQLType;)Ljava/lang/String;",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkIsAllOutputTypes$1",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/schema/validation/SchemaValidationError;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkIsAllOutputTypes$0",
+            "desc": "(Lgraphql/schema/GraphQLType;)Z",
+            "line": 63,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkIsAllInputTypes$1",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/schema/validation/SchemaValidationError;",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkIsAllInputTypes$0",
+            "desc": "(Lgraphql/schema/GraphQLType;)Z",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.validation.AppliedDirectivesAreValid": {
+        "line": {
+          "covered": 22,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 9,
+          "missed": 1
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLType",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkNonRepeatable",
+            "desc": "(Lgraphql/schema/validation/SchemaValidationErrorCollector;Lgraphql/schema/GraphQLDirectiveContainer;Lgraphql/schema/GraphQLDirective;Ljava/util/List;)V",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addNonRepeatableError",
+            "desc": "(Lgraphql/schema/validation/SchemaValidationErrorCollector;Lgraphql/schema/GraphQLDirectiveContainer;Ljava/lang/String;I)V",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addError",
+            "desc": "(Lgraphql/schema/validation/SchemaValidationErrorCollector;Ljava/lang/String;)V",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.validation.SchemaValidationError": {
+        "line": {
+          "covered": 8,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/validation/SchemaValidationErrorType;Ljava/lang/String;)V",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getClassification",
+            "desc": "()Lgraphql/schema/validation/SchemaValidationErrorClassification;",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDescription",
+            "desc": "()Ljava/lang/String;",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.validation.SchemaValidator": {
+        "line": {
+          "covered": 19,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 18,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getRules",
+            "desc": "()Ljava/util/List;",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateSchema",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Ljava/util/Set;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.validation.NoUnbrokenInputCycles": {
+        "line": {
+          "covered": 34,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 18,
+          "missed": 2
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "check",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;Ljava/util/Set;Ljava/util/List;Lgraphql/schema/validation/SchemaValidationErrorCollector;)V",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unwrapNonNull",
+            "desc": "(Lgraphql/schema/GraphQLNonNull;)Lgraphql/schema/GraphQLType;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrorMessage",
+            "desc": "(Ljava/util/List;)Ljava/lang/String;",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.validation.DefaultValuesAreValid": {
+        "line": {
+          "covered": 36,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 21,
+          "missed": 3
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputObjectType",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputObjectField",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 9,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLArgument",
+            "desc": "(Lgraphql/schema/GraphQLArgument;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 12,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isValidExternalValue",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Ljava/lang/Object;Lgraphql/schema/GraphQLInputType;Lgraphql/GraphQLContext;)Z",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.validation.DeprecatedInputObjectAndArgumentsAreValid": {
+        "line": {
+          "covered": 21,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 15,
+          "missed": 1
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputObjectField",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLArgument",
+            "desc": "(Lgraphql/schema/GraphQLArgument;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 9,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.validation.AppliedDirectiveArgumentsAreValid": {
+        "line": {
+          "covered": 36,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 20,
+          "missed": 2
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLAppliedDirective",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirective;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkArgument",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Lgraphql/schema/InputValueWithState;Lgraphql/schema/GraphQLInputType;Lgraphql/util/TraverserContext;)V",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 12,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isValidExternalValue",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Ljava/lang/Object;Lgraphql/schema/GraphQLInputType;Lgraphql/GraphQLContext;Ljava/util/Locale;)Z",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.validation.TypeAndFieldRule": {
+        "line": {
+          "covered": 94,
+          "missed": 18
+        },
+        "branch": {
+          "covered": 46,
+          "missed": 18
+        },
+        "method": {
+          "covered": 17,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInterfaceType",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLObjectType",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLUnionType",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLEnumType",
+            "desc": "(Lgraphql/schema/GraphQLEnumType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputObjectType",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateContainsField",
+            "desc": "(Lgraphql/schema/GraphQLFieldsContainer;Lgraphql/schema/validation/SchemaValidationErrorCollector;)V",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateInputObject",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;Lgraphql/schema/validation/SchemaValidationErrorCollector;)V",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateUnion",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;Lgraphql/schema/validation/SchemaValidationErrorCollector;)V",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateEnum",
+            "desc": "(Lgraphql/schema/GraphQLEnumType;Lgraphql/schema/validation/SchemaValidationErrorCollector;)V",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateFieldDefinition",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/validation/SchemaValidationErrorCollector;)V",
+            "line": 164,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateInputFieldDefinition",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLInputObjectField;Lgraphql/schema/validation/SchemaValidationErrorCollector;)V",
+            "line": 174,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateFieldDefinitionArgument",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Lgraphql/schema/GraphQLArgument;Lgraphql/schema/validation/SchemaValidationErrorCollector;)V",
+            "line": 179,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertArgumentName",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lgraphql/schema/validation/SchemaValidationErrorCollector;)V",
+            "line": 184,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertEnumValueDefinitionName",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Lgraphql/schema/validation/SchemaValidationErrorCollector;)V",
+            "line": 192,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertNonNullType",
+            "desc": "(Lgraphql/schema/GraphQLType;Lgraphql/schema/validation/SchemaValidationErrorCollector;)V",
+            "line": 200,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filterBuiltInTypes",
+            "desc": "(Ljava/util/List;)Ljava/util/List;",
+            "line": 208,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 4
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "assertFieldName",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Lgraphql/schema/validation/SchemaValidationErrorCollector;)V",
+            "line": 224,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$filterBuiltInTypes$0",
+            "desc": "(Lgraphql/schema/GraphQLNamedType;)Z",
+            "line": 213,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 6
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.validation.SchemaValidationErrorCollector": {
+        "line": {
+          "covered": 7,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 2
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 9,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addError",
+            "desc": "(Lgraphql/schema/validation/SchemaValidationError;)V",
+            "line": 14,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrors",
+            "desc": "()Ljava/util/Set;",
+            "line": 18,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "containsValidationError",
+            "desc": "(Lgraphql/schema/validation/SchemaValidationErrorType;)Z",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.validation.TypesImplementInterfaces": {
+        "line": {
+          "covered": 111,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 49,
+          "missed": 3
+        },
+        "method": {
+          "covered": 20,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLObjectType",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInterfaceType",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "check",
+            "desc": "(Lgraphql/schema/GraphQLImplementingType;Lgraphql/schema/validation/SchemaValidationErrorCollector;)V",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkObjectImplementsInterface",
+            "desc": "(Lgraphql/schema/GraphQLImplementingType;Lgraphql/schema/GraphQLInterfaceType;Lgraphql/schema/validation/SchemaValidationErrorCollector;)V",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkTransitiveImplementations",
+            "desc": "(Lgraphql/schema/GraphQLImplementingType;Lgraphql/schema/GraphQLInterfaceType;Lgraphql/schema/validation/SchemaValidationErrorCollector;)V",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkFieldTypeCompatibility",
+            "desc": "(Lgraphql/schema/GraphQLImplementingType;Lgraphql/schema/GraphQLInterfaceType;Lgraphql/schema/validation/SchemaValidationErrorCollector;Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/GraphQLFieldDefinition;)V",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkFieldArgumentEquivalence",
+            "desc": "(Lgraphql/schema/GraphQLImplementingType;Lgraphql/schema/GraphQLInterfaceType;Lgraphql/schema/validation/SchemaValidationErrorCollector;Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/GraphQLFieldDefinition;)V",
+            "line": 123,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "makeArgStr",
+            "desc": "(Lgraphql/schema/GraphQLArgument;)Ljava/lang/String;",
+            "line": 176,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "error",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/validation/SchemaValidationError;",
+            "line": 183,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isCompatible",
+            "desc": "(Lgraphql/schema/GraphQLOutputType;Lgraphql/schema/GraphQLOutputType;)Z",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 19,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 20,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isSameType",
+            "desc": "(Lgraphql/schema/GraphQLOutputType;Lgraphql/schema/GraphQLOutputType;)Z",
+            "line": 217,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "objectImplementsInterface",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;Lgraphql/schema/GraphQLObjectType;)Z",
+            "line": 223,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "interfaceImplementsInterface",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;Lgraphql/schema/GraphQLInterfaceType;)Z",
+            "line": 227,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "objectIsMemberOfUnion",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;Lgraphql/schema/GraphQLOutputType;)Z",
+            "line": 231,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkFieldArgumentEquivalence$1",
+            "desc": "(Ljava/util/Map;Lgraphql/schema/validation/SchemaValidationErrorCollector;Lgraphql/schema/GraphQLImplementingType;Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/GraphQLInterfaceType;Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/GraphQLArgument;)V",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 22,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 15,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkFieldArgumentEquivalence$0",
+            "desc": "(Ljava/util/List;Ljava/lang/String;)Z",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkTransitiveImplementations$0",
+            "desc": "(Lgraphql/schema/GraphQLImplementingType;Lgraphql/schema/validation/SchemaValidationErrorCollector;Lgraphql/schema/GraphQLInterfaceType;Ljava/util/List;Lgraphql/schema/GraphQLNamedOutputType;)V",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$check$0",
+            "desc": "(Lgraphql/schema/GraphQLImplementingType;Lgraphql/schema/validation/SchemaValidationErrorCollector;Lgraphql/schema/GraphQLNamedOutputType;)V",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$UnionAddition": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 616,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 621,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$ScalarAddition": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 995,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1000,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$InterfaceFieldArgumentRename": {
+        "line": {
+          "covered": 8,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 588,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 595,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewName",
+            "desc": "()Ljava/lang/String;",
+            "line": 599,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 603,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$ObjectModification": {
+        "line": {
+          "covered": 16,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 1,
+          "missed": 1
+        },
+        "method": {
+          "covered": 7,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDetails",
+            "desc": "()Ljava/util/List;",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDetails",
+            "desc": "(Ljava/lang/Class;)Ljava/util/List;",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewName",
+            "desc": "()Ljava/lang/String;",
+            "line": 97,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isNameChanged",
+            "desc": "()Z",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$InterfaceFieldArgumentDeletion": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 488,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 494,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 498,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$ScalarModification": {
+        "line": {
+          "covered": 16,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 1,
+          "missed": 1
+        },
+        "method": {
+          "covered": 7,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 1024,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 1024,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isNameChanged",
+            "desc": "()Z",
+            "line": 1041,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1045,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1049,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDetails",
+            "desc": "()Ljava/util/List;",
+            "line": 1053,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDetails",
+            "desc": "(Ljava/lang/Class;)Ljava/util/List;",
+            "line": 1057,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$AppliedDirectiveSchemaLocation": {
+        "line": {
+          "covered": 0,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 0,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 1319,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$EnumValueAddition": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 978,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 983,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$InputObjectModification": {
+        "line": {
+          "covered": 16,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 1,
+          "missed": 1
+        },
+        "method": {
+          "covered": 7,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 834,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 834,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isNameChanged",
+            "desc": "()Z",
+            "line": 850,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewName",
+            "desc": "()Ljava/lang/String;",
+            "line": 854,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 858,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDetails",
+            "desc": "()Ljava/util/List;",
+            "line": 862,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDetails",
+            "desc": "(Ljava/lang/Class;)Ljava/util/List;",
+            "line": 866,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$ObjectFieldArgumentTypeModification": {
+        "line": {
+          "covered": 10,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 266,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewType",
+            "desc": "()Ljava/lang/String;",
+            "line": 274,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldType",
+            "desc": "()Ljava/lang/String;",
+            "line": 278,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 282,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentName",
+            "desc": "()Ljava/lang/String;",
+            "line": 286,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$AppliedDirectiveArgumentRename": {
+        "line": {
+          "covered": 8,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/diffing/ana/SchemaDifference$AppliedDirectiveLocationDetail;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 1702,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocationDetail",
+            "desc": "()Lgraphql/schema/diffing/ana/SchemaDifference$AppliedDirectiveLocationDetail;",
+            "line": 1709,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1713,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1717,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$AppliedDirectiveObjectLocation": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 1328,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1334,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectiveName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1338,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$InterfaceFieldDeletion": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 431,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 436,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$EnumValueDeletion": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 948,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 953,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$AppliedDirectiveUnionLocation": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 1452,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1458,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectiveName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1462,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$InputObjectFieldDeletion": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 742,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 747,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$DirectiveArgumentAddition": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 1151,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1156,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$InputObjectFieldTypeModification": {
+        "line": {
+          "covered": 8,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 798,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 805,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldType",
+            "desc": "()Ljava/lang/String;",
+            "line": 809,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewType",
+            "desc": "()Ljava/lang/String;",
+            "line": 813,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$ObjectInterfaceImplementationAddition": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$UnionMemberAddition": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 684,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 689,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$InputObjectFieldRename": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 755,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 761,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewName",
+            "desc": "()Ljava/lang/String;",
+            "line": 765,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$ScalarDeletion": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 1007,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1012,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$EnumDeletion": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 891,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 896,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$EnumModification": {
+        "line": {
+          "covered": 16,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 1,
+          "missed": 1
+        },
+        "method": {
+          "covered": 7,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 905,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 905,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isNameChanged",
+            "desc": "()Z",
+            "line": 920,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewName",
+            "desc": "()Ljava/lang/String;",
+            "line": 924,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 928,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDetails",
+            "desc": "()Ljava/util/List;",
+            "line": 932,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDetails",
+            "desc": "(Ljava/lang/Class;)Ljava/util/List;",
+            "line": 936,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$AppliedDirectiveObjectFieldLocation": {
+        "line": {
+          "covered": 8,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 1255,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1262,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getObjectName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1266,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectiveName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1270,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$ObjectAddition": {
+        "line": {
+          "covered": 3,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$ObjectFieldRename": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 161,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewName",
+            "desc": "()Ljava/lang/String;",
+            "line": 167,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 171,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$AppliedDirectiveInterfaceLocation": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 1346,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1352,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectiveName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1356,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$AppliedDirectiveArgumentDeletion": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/diffing/ana/SchemaDifference$AppliedDirectiveLocationDetail;Ljava/lang/String;)V",
+            "line": 1646,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocationDetail",
+            "desc": "()Lgraphql/schema/diffing/ana/SchemaDifference$AppliedDirectiveLocationDetail;",
+            "line": 1652,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1656,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$InputObjectAddition": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 714,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 719,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$UnionDeletion": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 628,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 633,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$EnumValueRenamed": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 961,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 967,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewName",
+            "desc": "()Ljava/lang/String;",
+            "line": 971,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$ObjectFieldTypeModification": {
+        "line": {
+          "covered": 8,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 204,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 211,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewType",
+            "desc": "()Ljava/lang/String;",
+            "line": 215,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldType",
+            "desc": "()Ljava/lang/String;",
+            "line": 219,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$AppliedDirectiveInterfaceFieldArgumentLocation": {
+        "line": {
+          "covered": 10,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 1423,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInterfaceName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1431,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1435,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1439,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectiveName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1443,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$InputObjectFieldDefaultValueModification": {
+        "line": {
+          "covered": 7,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 774,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 781,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getOldDefaultValue",
+            "desc": "()Ljava/lang/String;",
+            "line": 785,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewDefaultValue",
+            "desc": "()Ljava/lang/String;",
+            "line": 789,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$InterfaceFieldTypeModification": {
+        "line": {
+          "covered": 8,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 464,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 471,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewType",
+            "desc": "()Ljava/lang/String;",
+            "line": 475,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldType",
+            "desc": "()Ljava/lang/String;",
+            "line": 479,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$AppliedDirectiveObjectFieldArgumentLocation": {
+        "line": {
+          "covered": 10,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 1367,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getObjectName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1375,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1379,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1383,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectiveName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1387,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$DirectiveArgumentRename": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 1213,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1219,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1223,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$DirectiveDeletion": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 1082,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1087,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$AppliedDirectiveDirectiveArgumentLocation": {
+        "line": {
+          "covered": 8,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 1397,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectiveName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1404,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1408,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectiveDefinitionName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1412,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$InterfaceAddition": {
+        "line": {
+          "covered": 3,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 328,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 333,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$ObjectFieldArgumentDeletion": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 227,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 233,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 237,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$AppliedDirectiveAddition": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/diffing/ana/SchemaDifference$AppliedDirectiveLocationDetail;Ljava/lang/String;)V",
+            "line": 1566,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1572,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocationDetail",
+            "desc": "()Lgraphql/schema/diffing/ana/SchemaDifference$AppliedDirectiveLocationDetail;",
+            "line": 1576,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.EditOperationAnalysisResult": {
+        "line": {
+          "covered": 16,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 8,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;)V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getObjectDifferences",
+            "desc": "()Ljava/util/Map;",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInterfaceDifferences",
+            "desc": "()Ljava/util/Map;",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getUnionDifferences",
+            "desc": "()Ljava/util/Map;",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getEnumDifferences",
+            "desc": "()Ljava/util/Map;",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInputObjectDifferences",
+            "desc": "()Ljava/util/Map;",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getScalarDifferences",
+            "desc": "()Ljava/util/Map;",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectiveDifferences",
+            "desc": "()Ljava/util/Map;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$InterfaceFieldRename": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 444,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewName",
+            "desc": "()Ljava/lang/String;",
+            "line": 450,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 454,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$InterfaceInterfaceImplementationDeletion": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 407,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 412,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$ObjectFieldDeletion": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 148,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$DirectiveArgumentTypeModification": {
+        "line": {
+          "covered": 8,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 1166,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1173,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewType",
+            "desc": "()Ljava/lang/String;",
+            "line": 1177,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldType",
+            "desc": "()Ljava/lang/String;",
+            "line": 1181,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$DirectiveArgumentDefaultValueModification": {
+        "line": {
+          "covered": 8,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 1190,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldValue",
+            "desc": "()Ljava/lang/String;",
+            "line": 1197,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewValue",
+            "desc": "()Ljava/lang/String;",
+            "line": 1201,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1205,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$AppliedDirectiveEnumValueLocation": {
+        "line": {
+          "covered": 8,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 1491,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getEnumName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1498,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getValueName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1502,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectiveName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1506,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$ObjectFieldArgumentRename": {
+        "line": {
+          "covered": 8,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 180,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 187,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewName",
+            "desc": "()Ljava/lang/String;",
+            "line": 191,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 195,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$InputObjectFieldAddition": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 820,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 825,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$InterfaceInterfaceImplementationAddition": {
+        "line": {
+          "covered": 0,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 0,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 395,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 400,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$ObjectFieldArgumentDefaultValueModification": {
+        "line": {
+          "covered": 10,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 296,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldValue",
+            "desc": "()Ljava/lang/String;",
+            "line": 304,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewValue",
+            "desc": "()Ljava/lang/String;",
+            "line": 308,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 312,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentName",
+            "desc": "()Ljava/lang/String;",
+            "line": 316,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$ObjectFieldArgumentAddition": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 246,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 252,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 256,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$InputObjectDeletion": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 726,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 731,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$AppliedDirectiveScalarLocation": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 1305,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1311,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectiveName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1315,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$InterfaceModification": {
+        "line": {
+          "covered": 16,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 1,
+          "missed": 1
+        },
+        "method": {
+          "covered": 7,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 353,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 353,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDetails",
+            "desc": "()Ljava/util/List;",
+            "line": 368,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewName",
+            "desc": "()Ljava/lang/String;",
+            "line": 372,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 376,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isNameChanged",
+            "desc": "()Z",
+            "line": 380,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDetails",
+            "desc": "(Ljava/lang/Class;)Ljava/util/List;",
+            "line": 384,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$ObjectInterfaceImplementationDeletion": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 124,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$UnionMemberDeletion": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 696,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 701,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$AppliedDirectiveInputObjectLocation": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 1515,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1521,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectiveName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1525,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$InterfaceDeletion": {
+        "line": {
+          "covered": 3,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 340,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 345,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$InterfaceFieldArgumentDefaultValueModification": {
+        "line": {
+          "covered": 10,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 559,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldValue",
+            "desc": "()Ljava/lang/String;",
+            "line": 567,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewValue",
+            "desc": "()Ljava/lang/String;",
+            "line": 571,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 575,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentName",
+            "desc": "()Ljava/lang/String;",
+            "line": 579,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.EditOperationAnalyzer": {
+        "line": {
+          "covered": 1510,
+          "missed": 150
+        },
+        "branch": {
+          "covered": 819,
+          "missed": 193
+        },
+        "method": {
+          "covered": 138,
+          "missed": 9
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLSchema;Lgraphql/schema/diffing/SchemaGraph;Lgraphql/schema/diffing/SchemaGraph;)V",
+            "line": 119,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "analyzeEdits",
+            "desc": "(Ljava/util/List;Lgraphql/schema/diffing/Mapping;)Lgraphql/schema/diffing/ana/EditOperationAnalysisResult;",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 30,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 24,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleArgumentChanges",
+            "desc": "(Ljava/util/List;Lgraphql/schema/diffing/Mapping;)V",
+            "line": 193,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 9,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleAppliedDirectives",
+            "desc": "(Ljava/util/List;Lgraphql/schema/diffing/Mapping;)V",
+            "line": 215,
+            "counters": {
+              "line": {
+                "covered": 18,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 22,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "appliedDirectiveDeleted",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 257,
+            "counters": {
+              "line": {
+                "covered": 59,
+                "missed": 10
+              },
+              "branch": {
+                "covered": 29,
+                "missed": 11
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "appliedDirectiveArgumentDeleted",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 339,
+            "counters": {
+              "line": {
+                "covered": 114,
+                "missed": 24
+              },
+              "branch": {
+                "covered": 72,
+                "missed": 26
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "appliedDirectiveArgumentAdded",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 524,
+            "counters": {
+              "line": {
+                "covered": 109,
+                "missed": 28
+              },
+              "branch": {
+                "covered": 68,
+                "missed": 30
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "appliedDirectiveArgumentChanged",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 705,
+            "counters": {
+              "line": {
+                "covered": 114,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 59,
+                "missed": 27
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "appliedDirectiveAdded",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 871,
+            "counters": {
+              "line": {
+                "covered": 59,
+                "missed": 10
+              },
+              "branch": {
+                "covered": 29,
+                "missed": 11
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "appliedDirectiveDeletedFromField",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/Vertex;)V",
+            "line": 954,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "appliedDirectiveAddedToField",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/Vertex;)V",
+            "line": 972,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "appliedDirectiveDeletedFromArgument",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/Vertex;)V",
+            "line": 990,
+            "counters": {
+              "line": {
+                "covered": 31,
+                "missed": 8
+              },
+              "branch": {
+                "covered": 12,
+                "missed": 8
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "appliedDirectiveAddedToArgument",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/Vertex;)V",
+            "line": 1041,
+            "counters": {
+              "line": {
+                "covered": 31,
+                "missed": 8
+              },
+              "branch": {
+                "covered": 12,
+                "missed": 8
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleTypeChanges",
+            "desc": "(Ljava/util/List;Lgraphql/schema/diffing/Mapping;)V",
+            "line": 1092,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 9,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleUnionMemberChanges",
+            "desc": "(Ljava/util/List;Lgraphql/schema/diffing/Mapping;)V",
+            "line": 1110,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 11,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleEnumValuesChanges",
+            "desc": "(Ljava/util/List;Lgraphql/schema/diffing/Mapping;)V",
+            "line": 1129,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 17,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleInputFieldChange",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 1153,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleArgumentChange",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;Lgraphql/schema/diffing/Mapping;)V",
+            "line": 1172,
+            "counters": {
+              "line": {
+                "covered": 28,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleImplementsChanges",
+            "desc": "(Ljava/util/List;Lgraphql/schema/diffing/Mapping;)V",
+            "line": 1211,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 9,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleUnionMemberAdded",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 1230,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleUnionMemberDeleted",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 1241,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleEnumValueAdded",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 1252,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleEnumValueDeleted",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 1263,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleEnumValueChanged",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 1274,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldChanged",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 1282,
+            "counters": {
+              "line": {
+                "covered": 18,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inputFieldAdded",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 1315,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldAdded",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 1325,
+            "counters": {
+              "line": {
+                "covered": 18,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inputFieldDeleted",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 1348,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldDeleted",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 1357,
+            "counters": {
+              "line": {
+                "covered": 18,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleTypeVertexChanges",
+            "desc": "(Ljava/util/List;)V",
+            "line": 1381,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "insertedTypeVertex",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 1397,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deletedTypeVertex",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 1424,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "changedTypeVertex",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 1450,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "typeEdgeInserted",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;Ljava/util/List;Lgraphql/schema/diffing/Mapping;)V",
+            "line": 1478,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "typeEdgeInsertedForInputField",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;Ljava/util/List;Lgraphql/schema/diffing/Mapping;)V",
+            "line": 1493,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "typeEdgeInsertedForArgument",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;Ljava/util/List;Lgraphql/schema/diffing/Mapping;)V",
+            "line": 1511,
+            "counters": {
+              "line": {
+                "covered": 56,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 25,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "typeEdgeInsertedForField",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;Ljava/util/List;Lgraphql/schema/diffing/Mapping;)V",
+            "line": 1605,
+            "counters": {
+              "line": {
+                "covered": 26,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "findDeletedEdge",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Ljava/util/List;Lgraphql/schema/diffing/Mapping;Ljava/util/function/Predicate;)Lgraphql/schema/diffing/EditOperation;",
+            "line": 1648,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "typeEdgeChanged",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;Lgraphql/schema/diffing/Mapping;)V",
+            "line": 1662,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inputFieldTypeOrDefaultValueChanged",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 1674,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "argumentTypeOrDefaultValueChanged",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;Lgraphql/schema/diffing/Mapping;)V",
+            "line": 1697,
+            "counters": {
+              "line": {
+                "covered": 44,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 16,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "doesArgumentChangeMakeSense",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/Mapping;)Z",
+            "line": 1769,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "outputFieldTypeChanged",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 1777,
+            "counters": {
+              "line": {
+                "covered": 19,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeFromEdgeLabel",
+            "desc": "(Lgraphql/schema/diffing/Edge;)Ljava/lang/String;",
+            "line": 1800,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefaultValueFromEdgeLabel",
+            "desc": "(Lgraphql/schema/diffing/Edge;)Ljava/lang/String;",
+            "line": 1807,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isTypeEdge",
+            "desc": "(Lgraphql/schema/diffing/Edge;)Z",
+            "line": 1814,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "interfaceImplementationDeleted",
+            "desc": "(Lgraphql/schema/diffing/Edge;)V",
+            "line": 1819,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newInterfaceAddedToInterfaceOrObject",
+            "desc": "(Lgraphql/schema/diffing/Edge;)V",
+            "line": 1843,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 7
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isDirectiveAdded",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 1867,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isDirectiveDeleted",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 1871,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isObjectAdded",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 1875,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isUnionAdded",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 1879,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isUnionDeleted",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 1883,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEnumDeleted",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 1887,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEnumAdded",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 1891,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isInputObjectAdded",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 1895,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isInputObjectDeleted",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 1899,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isInputFieldAdded",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 1903,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 4
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isAppliedDirectiveAdded",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Ljava/lang/String;)Z",
+            "line": 1907,
+            "counters": {
+              "line": {
+                "covered": 45,
+                "missed": 11
+              },
+              "branch": {
+                "covered": 33,
+                "missed": 9
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isAppliedDirectiveDeleted",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Ljava/lang/String;)Z",
+            "line": 1983,
+            "counters": {
+              "line": {
+                "covered": 50,
+                "missed": 6
+              },
+              "branch": {
+                "covered": 35,
+                "missed": 7
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isNewInputFieldExistingInputObject",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Z",
+            "line": 2051,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isInputFieldDeletedFromExistingInputObject",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Z",
+            "line": 2063,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isArgumentNewForExistingDirective",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Z",
+            "line": 2075,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isArgumentDeletedFromExistingDirective",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Z",
+            "line": 2087,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isArgumentNewForExistingObjectField",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Z",
+            "line": 2099,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isArgumentDeletedFromExistingObjectField",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Z",
+            "line": 2119,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isArgumentDeletedFromExistingInterfaceField",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Z",
+            "line": 2139,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isArgumentNewForExistingInterfaceField",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Z",
+            "line": 2158,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isFieldNewForExistingObject",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Z",
+            "line": 2177,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isFieldDeletedFromExistingInterface",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Z",
+            "line": 2189,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isFieldDeletedFromExistingObject",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Z",
+            "line": 2201,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isNewEnumValueForExistingEnum",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Z",
+            "line": 2213,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEnumValueDeletedFromExistingEnum",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Z",
+            "line": 2225,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 5
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isFieldNewForExistingInterface",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Z",
+            "line": 2237,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isObjectDeleted",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 2249,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isInterfaceDeleted",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 2253,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isInterfaceAdded",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 2257,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isScalarAdded",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 2261,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isScalarDeleted",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 2265,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getObjectModification",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/diffing/ana/SchemaDifference$ObjectModification;",
+            "line": 2269,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getUnionModification",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/diffing/ana/SchemaDifference$UnionModification;",
+            "line": 2277,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getEnumModification",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/diffing/ana/SchemaDifference$EnumModification;",
+            "line": 2285,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInputObjectModification",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/diffing/ana/SchemaDifference$InputObjectModification;",
+            "line": 2293,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectiveModification",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/diffing/ana/SchemaDifference$DirectiveModification;",
+            "line": 2301,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInterfaceModification",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/diffing/ana/SchemaDifference$InterfaceModification;",
+            "line": 2309,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getScalarModification",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/diffing/ana/SchemaDifference$ScalarModification;",
+            "line": 2317,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addedObject",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 2326,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addedInterface",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 2332,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addedUnion",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 2339,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addedInputObject",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 2346,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addedEnum",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 2353,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addedScalar",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 2360,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addedDirective",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 2372,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "removedObject",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 2380,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "removedInterface",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 2387,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "removedUnion",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 2394,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "removedInputObject",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 2401,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "removedEnum",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 2408,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deletedScalar",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 2415,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deletedDirective",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 2422,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "argumentDeleted",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 2431,
+            "counters": {
+              "line": {
+                "covered": 35,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 22,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "argumentAdded",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 2480,
+            "counters": {
+              "line": {
+                "covered": 34,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 21,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "changedEnum",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 2530,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "changedScalar",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 2544,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "changedInputObject",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 2558,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "changedDirective",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 2572,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "changedObject",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 2586,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "changedInterface",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 2600,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "changedUnion",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)V",
+            "line": 2614,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTraversalOrder",
+            "desc": "(Ljava/util/List;)Ljava/util/List;",
+            "line": 2677,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isAnyVertexOfType",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;Ljava/lang/String;)Z",
+            "line": 2707,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 16,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isAnyVertexOfType",
+            "desc": "(Lgraphql/schema/diffing/Edge;Ljava/lang/String;)Z",
+            "line": 2714,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getTraversalOrder$1",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)Ljava/lang/Integer;",
+            "line": 2691,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getTraversalOrder$0",
+            "desc": "(Lgraphql/schema/diffing/EditOperation;)I",
+            "line": 2682,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isFieldNewForExistingInterface$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$InterfaceFieldAddition;)Z",
+            "line": 2245,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isEnumValueDeletedFromExistingEnum$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$EnumValueDeletion;)Z",
+            "line": 2233,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$isNewEnumValueForExistingEnum$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$EnumValueAddition;)Z",
+            "line": 2221,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$isFieldDeletedFromExistingObject$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$ObjectFieldDeletion;)Z",
+            "line": 2209,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isFieldDeletedFromExistingInterface$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$InterfaceFieldDeletion;)Z",
+            "line": 2197,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isFieldNewForExistingObject$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$ObjectFieldAddition;)Z",
+            "line": 2185,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isArgumentNewForExistingInterfaceField$1",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$InterfaceFieldArgumentAddition;)Z",
+            "line": 2173,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isArgumentNewForExistingInterfaceField$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$InterfaceFieldAddition;)Z",
+            "line": 2167,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$isArgumentDeletedFromExistingInterfaceField$1",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$InterfaceFieldArgumentDeletion;)Z",
+            "line": 2154,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isArgumentDeletedFromExistingInterfaceField$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$InterfaceFieldDeletion;)Z",
+            "line": 2148,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$isArgumentDeletedFromExistingObjectField$1",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$ObjectFieldArgumentDeletion;)Z",
+            "line": 2134,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isArgumentDeletedFromExistingObjectField$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$ObjectFieldDeletion;)Z",
+            "line": 2128,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$isArgumentNewForExistingObjectField$1",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$ObjectFieldArgumentAddition;)Z",
+            "line": 2114,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isArgumentNewForExistingObjectField$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$ObjectFieldAddition;)Z",
+            "line": 2108,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$isArgumentDeletedFromExistingDirective$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$DirectiveArgumentDeletion;)Z",
+            "line": 2095,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isArgumentNewForExistingDirective$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$DirectiveArgumentAddition;)Z",
+            "line": 2083,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isInputFieldDeletedFromExistingInputObject$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$InputObjectFieldDeletion;)Z",
+            "line": 2071,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$isNewInputFieldExistingInputObject$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$InputObjectFieldAddition;)Z",
+            "line": 2059,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isAppliedDirectiveDeleted$6",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$AppliedDirectiveDeletion;)Z",
+            "line": 2043,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isAppliedDirectiveDeleted$5",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$AppliedDirectiveDeletion;)Z",
+            "line": 2034,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isAppliedDirectiveDeleted$4",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$AppliedDirectiveDeletion;)Z",
+            "line": 2025,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isAppliedDirectiveDeleted$3",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$AppliedDirectiveDeletion;)Z",
+            "line": 2016,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isAppliedDirectiveDeleted$2",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$AppliedDirectiveDeletion;)Z",
+            "line": 2007,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isAppliedDirectiveDeleted$1",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$AppliedDirectiveDeletion;)Z",
+            "line": 1998,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isAppliedDirectiveDeleted$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$AppliedDirectiveDeletion;)Z",
+            "line": 1989,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isAppliedDirectiveAdded$6",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$AppliedDirectiveAddition;)Z",
+            "line": 1967,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$isAppliedDirectiveAdded$5",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$AppliedDirectiveAddition;)Z",
+            "line": 1958,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isAppliedDirectiveAdded$4",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$AppliedDirectiveAddition;)Z",
+            "line": 1949,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isAppliedDirectiveAdded$3",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$AppliedDirectiveAddition;)Z",
+            "line": 1940,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isAppliedDirectiveAdded$2",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$AppliedDirectiveAddition;)Z",
+            "line": 1931,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isAppliedDirectiveAdded$1",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$AppliedDirectiveAddition;)Z",
+            "line": 1922,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isAppliedDirectiveAdded$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/ana/SchemaDifference$AppliedDirectiveAddition;)Z",
+            "line": 1913,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 2632,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$DirectiveModification": {
+        "line": {
+          "covered": 16,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 1,
+          "missed": 1
+        },
+        "method": {
+          "covered": 7,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 1096,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 1096,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isNameChanged",
+            "desc": "()Z",
+            "line": 1111,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1115,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1119,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDetails",
+            "desc": "()Ljava/util/List;",
+            "line": 1123,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDetails",
+            "desc": "(Ljava/lang/Class;)Ljava/util/List;",
+            "line": 1127,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$AppliedDirectiveArgumentAddition": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/diffing/ana/SchemaDifference$AppliedDirectiveLocationDetail;Ljava/lang/String;)V",
+            "line": 1622,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocationDetail",
+            "desc": "()Lgraphql/schema/diffing/ana/SchemaDifference$AppliedDirectiveLocationDetail;",
+            "line": 1628,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1632,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$DirectiveAddition": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 1070,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1075,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$AppliedDirectiveEnumLocation": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 1471,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1477,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectiveName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1481,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$InterfaceFieldArgumentAddition": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 506,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 512,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 516,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$ObjectDeletion": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$UnionModification": {
+        "line": {
+          "covered": 16,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 1,
+          "missed": 1
+        },
+        "method": {
+          "covered": 7,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 642,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 642,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewName",
+            "desc": "()Ljava/lang/String;",
+            "line": 657,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 661,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDetails",
+            "desc": "()Ljava/util/List;",
+            "line": 665,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDetails",
+            "desc": "(Ljava/lang/Class;)Ljava/util/List;",
+            "line": 669,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isNameChanged",
+            "desc": "()Z",
+            "line": 673,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$EnumAddition": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 879,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 884,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$AppliedDirectiveRenamed": {
+        "line": {
+          "covered": 0,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 0,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 1608,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$AppliedDirectiveDeletion": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/diffing/ana/SchemaDifference$AppliedDirectiveLocationDetail;Ljava/lang/String;)V",
+            "line": 1592,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1598,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocationDetail",
+            "desc": "()Lgraphql/schema/diffing/ana/SchemaDifference$AppliedDirectiveLocationDetail;",
+            "line": 1602,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$AppliedDirectiveArgumentValueModification": {
+        "line": {
+          "covered": 10,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/diffing/ana/SchemaDifference$AppliedDirectiveLocationDetail;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 1673,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocationDetail",
+            "desc": "()Lgraphql/schema/diffing/ana/SchemaDifference$AppliedDirectiveLocationDetail;",
+            "line": 1681,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1685,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldValue",
+            "desc": "()Ljava/lang/String;",
+            "line": 1689,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewValue",
+            "desc": "()Ljava/lang/String;",
+            "line": 1693,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$ObjectFieldAddition": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 141,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$AppliedDirectiveInputObjectFieldLocation": {
+        "line": {
+          "covered": 8,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 1536,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInputObjectName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1543,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1547,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectiveName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1551,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$DirectiveArgumentDeletion": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 1138,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1143,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$InterfaceFieldArgumentTypeModification": {
+        "line": {
+          "covered": 10,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 527,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 535,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewType",
+            "desc": "()Ljava/lang/String;",
+            "line": 539,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldType",
+            "desc": "()Ljava/lang/String;",
+            "line": 543,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentName",
+            "desc": "()Ljava/lang/String;",
+            "line": 547,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$InterfaceFieldAddition": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 419,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 424,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.ana.SchemaDifference$AppliedDirectiveInterfaceFieldLocation": {
+        "line": {
+          "covered": 8,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 1281,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1288,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInterfaceName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1292,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectiveName",
+            "desc": "()Ljava/lang/String;",
+            "line": 1296,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.usage.SchemaUsage": {
+        "line": {
+          "covered": 77,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 44,
+          "missed": 4
+        },
+        "method": {
+          "covered": 13,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/usage/SchemaUsage$Builder;)V",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldReferenceCounts",
+            "desc": "()Ljava/util/Map;",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOutputFieldReferenceCounts",
+            "desc": "()Ljava/util/Map;",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInputFieldReferenceCounts",
+            "desc": "()Ljava/util/Map;",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentReferenceCounts",
+            "desc": "()Ljava/util/Map;",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInterfaceReferenceCounts",
+            "desc": "()Ljava/util/Map;",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getUnionReferenceCounts",
+            "desc": "()Ljava/util/Map;",
+            "line": 118,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectiveReferenceCounts",
+            "desc": "()Ljava/util/Map;",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isStronglyReferenced",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Ljava/lang/String;)Z",
+            "line": 145,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getUnReferencedElements",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Ljava/util/Set;",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isReferencedImpl",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Ljava/lang/String;Ljava/util/Set;)Z",
+            "line": 171,
+            "counters": {
+              "line": {
+                "covered": 42,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 36,
+                "missed": 4
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isNamedElementReferenced",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Ljava/lang/String;Ljava/util/Set;)Z",
+            "line": 243,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getUnReferencedElements$1",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Ljava/util/Set;Lgraphql/schema/GraphQLDirective;)V",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getUnReferencedElements$0",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Ljava/util/Set;Lgraphql/schema/GraphQLNamedType;)V",
+            "line": 158,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.usage.SchemaUsageSupport$1": {
+        "line": {
+          "covered": 71,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 22,
+          "missed": 2
+        },
+        "method": {
+          "covered": 19,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/usage/SchemaUsage$Builder;)V",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "incCount",
+            "desc": "()Ljava/util/function/BiFunction;",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "recordBackReference",
+            "desc": "(Lgraphql/schema/GraphQLNamedSchemaElement;Lgraphql/schema/GraphQLSchemaElement;)V",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "memberInterfaces",
+            "desc": "(Lgraphql/schema/GraphQLNamedType;Ljava/util/List;)V",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLArgument",
+            "desc": "(Lgraphql/schema/GraphQLArgument;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLAppliedDirectiveArgument",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirectiveArgument;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputObjectField",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 119,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLAppliedDirective",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirective;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitDirectiveLike",
+            "desc": "(Lgraphql/util/TraverserContext;Ljava/lang/String;)Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 143,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLUnionType",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 166,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInterfaceType",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 178,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLObjectType",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 184,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLUnionType$0",
+            "desc": "(Ljava/lang/String;)Ljava/util/Set;",
+            "line": 169,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$memberInterfaces$0",
+            "desc": "(Ljava/lang/String;)Ljava/util/Set;",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$recordBackReference$2",
+            "desc": "(Ljava/lang/String;)Ljava/util/Set;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$recordBackReference$1",
+            "desc": "(Ljava/lang/String;)Ljava/util/Set;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$recordBackReference$0",
+            "desc": "(Ljava/lang/String;)Ljava/util/Set;",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$incCount$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/Integer;)Ljava/lang/Integer;",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.usage.SchemaUsageSupport": {
+        "line": {
+          "covered": 5,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getSchemaUsage",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Lgraphql/schema/usage/SchemaUsage;",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.usage.SchemaUsage$Builder": {
+        "line": {
+          "covered": 12,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 253,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/usage/SchemaUsage;",
+            "line": 267,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.exceptions.ParseCancelledException": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/i18n/I18n;Lgraphql/language/SourceLocation;Ljava/lang/String;ILjava/lang/String;)V",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.exceptions.ParseCancelledTooManyCharsException": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/i18n/I18n;I)V",
+            "line": 13,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.exceptions.InvalidUnicodeSyntaxException": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/i18n/I18n;Ljava/lang/String;Lgraphql/language/SourceLocation;Ljava/lang/String;)V",
+            "line": 13,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.exceptions.MoreTokensSyntaxException": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/i18n/I18n;Lgraphql/language/SourceLocation;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 14,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/i18n/I18n;Lgraphql/language/SourceLocation;)V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.exceptions.ParseCancelledTooDeepException": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/i18n/I18n;Lgraphql/language/SourceLocation;Ljava/lang/String;ILjava/lang/String;)V",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.i18n.I18n$BundleType": {
+        "line": {
+          "covered": 9,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;I)V",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.i18n.I18nMsg": {
+        "line": {
+          "covered": 6,
+          "missed": 8
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/List;)V",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;[Ljava/lang/Object;)V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getMsgKey",
+            "desc": "()Ljava/lang/String;",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMsgArguments",
+            "desc": "()[Ljava/lang/Object;",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addArgumentAt",
+            "desc": "(ILjava/lang/Object;)Lgraphql/i18n/I18nMsg;",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toI18n",
+            "desc": "(Lgraphql/i18n/I18n;)Ljava/lang/String;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.i18n.I18n": {
+        "line": {
+          "covered": 15,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/i18n/I18n$BundleType;Ljava/util/Locale;)V",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocale",
+            "desc": "()Ljava/util/Locale;",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getResourceBundle",
+            "desc": "()Ljava/util/ResourceBundle;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "i18n",
+            "desc": "(Lgraphql/i18n/I18n$BundleType;Ljava/util/Locale;)Lgraphql/i18n/I18n;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "msg",
+            "desc": "(Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "msg",
+            "desc": "(Ljava/lang/String;Ljava/util/List;)Ljava/lang/String;",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "msgImpl",
+            "desc": "(Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.visibility.BlockedFields": {
+        "line": {
+          "covered": 24,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 15,
+          "missed": 1
+        },
+        "method": {
+          "covered": 10,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;)V",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinitions",
+            "desc": "(Lgraphql/schema/GraphQLFieldsContainer;)Ljava/util/List;",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLFieldsContainer;Ljava/lang/String;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinitions",
+            "desc": "(Lgraphql/schema/GraphQLInputFieldsContainer;)Ljava/util/List;",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLInputFieldsContainer;Ljava/lang/String;)Lgraphql/schema/GraphQLInputObjectField;",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "block",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkFQN",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newBlock",
+            "desc": "()Lgraphql/schema/visibility/BlockedFields$Builder;",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getFieldDefinitions$1",
+            "desc": "(Lgraphql/schema/GraphQLInputFieldsContainer;Lgraphql/schema/GraphQLInputObjectField;)Z",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getFieldDefinitions$0",
+            "desc": "(Lgraphql/schema/GraphQLFieldsContainer;Lgraphql/schema/GraphQLFieldDefinition;)Z",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.visibility.NoIntrospectionGraphqlFieldVisibility": {
+        "line": {
+          "covered": 5,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinitions",
+            "desc": "(Lgraphql/schema/GraphQLFieldsContainer;)Ljava/util/List;",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLFieldsContainer;Ljava/lang/String;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.visibility.BlockedFields$Builder": {
+        "line": {
+          "covered": 8,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addPattern",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/visibility/BlockedFields$Builder;",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addPatterns",
+            "desc": "(Ljava/util/Collection;)Lgraphql/schema/visibility/BlockedFields$Builder;",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addCompiledPattern",
+            "desc": "(Ljava/util/regex/Pattern;)Lgraphql/schema/visibility/BlockedFields$Builder;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addCompiledPatterns",
+            "desc": "(Ljava/util/Collection;)Lgraphql/schema/visibility/BlockedFields$Builder;",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/visibility/BlockedFields;",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.visibility.GraphqlFieldVisibility": {
+        "line": {
+          "covered": 0,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 0,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "getFieldDefinitions",
+            "desc": "(Lgraphql/schema/GraphQLInputFieldsContainer;)Ljava/util/List;",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLInputFieldsContainer;Ljava/lang/String;)Lgraphql/schema/GraphQLInputObjectField;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.visibility.DefaultGraphqlFieldVisibility": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinitions",
+            "desc": "(Lgraphql/schema/GraphQLFieldsContainer;)Ljava/util/List;",
+            "line": 21,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLFieldsContainer;Ljava/lang/String;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinitions",
+            "desc": "(Lgraphql/schema/GraphQLInputFieldsContainer;)Ljava/util/List;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLInputFieldsContainer;Ljava/lang/String;)Lgraphql/schema/GraphQLInputObjectField;",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.dataloader.DataLoaderDispatchingContextKeys": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "setEnableDataLoaderChaining",
+            "desc": "(Lgraphql/GraphQLContext;Z)V",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setEnableDataLoaderExhaustedDispatching",
+            "desc": "(Lgraphql/GraphQLContext;Z)V",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.dataloader.PerLevelDataLoaderDispatchStrategy$ChainedDLStack": {
+        "line": {
+          "covered": 40,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 23,
+          "missed": 1
+        },
+        "method": {
+          "covered": 6,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "aboutToStartDispatching",
+            "desc": "(IZZ)Lgraphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy$ChainedDLStack$StateForLevel;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 20,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 13,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newDataLoaderInvocation",
+            "desc": "(ILorg/dataloader/DataLoader;)Z",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clear",
+            "desc": "()V",
+            "line": 145,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$newDataLoaderInvocation$0",
+            "desc": "(Ljava/lang/Integer;)Ljava/util/concurrent/atomic/AtomicReference;",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$aboutToStartDispatching$0",
+            "desc": "(Ljava/lang/Integer;)Ljava/util/concurrent/atomic/AtomicReference;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.dataloader.EmptyDataLoaderRegistryInstance$1": {
+        "line": {
+          "covered": 1,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 10,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "register",
+            "desc": "(Ljava/lang/String;Lorg/dataloader/DataLoader;)Lorg/dataloader/DataLoaderRegistry;",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "computeIfAbsent",
+            "desc": "(Ljava/lang/String;Ljava/util/function/Function;)Lorg/dataloader/DataLoader;",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "unregister",
+            "desc": "(Ljava/lang/String;)Lorg/dataloader/DataLoaderRegistry;",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.dataloader.EmptyDataLoaderRegistryInstance": {
+        "line": {
+          "covered": 1,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 9,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 10,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.dataloader.PerLevelDataLoaderDispatchStrategy$CallStack": {
+        "line": {
+          "covered": 19,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 219,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "get",
+            "desc": "(I)Lgraphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy$CallStack$StateForLevel;",
+            "line": 236,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "tryUpdateLevel",
+            "desc": "(ILgraphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy$CallStack$StateForLevel;Lgraphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy$CallStack$StateForLevel;)Z",
+            "line": 241,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clear",
+            "desc": "()V",
+            "line": 247,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$get$0",
+            "desc": "(Ljava/lang/Integer;)Ljava/util/concurrent/atomic/AtomicReference;",
+            "line": 236,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.dataloader.ExhaustedDataLoaderDispatchStrategy$CallStack": {
+        "line": {
+          "covered": 29,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 12,
+          "missed": 0
+        },
+        "method": {
+          "covered": 12,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "getObjectRunningCount",
+            "desc": "(I)I",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setObjectRunningCount",
+            "desc": "(II)I",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setDataLoaderToDispatch",
+            "desc": "(IZ)I",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setCurrentlyDispatching",
+            "desc": "(IZ)I",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDataLoaderToDispatch",
+            "desc": "(I)Z",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCurrentlyDispatching",
+            "desc": "(I)Z",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "incrementObjectRunningCount",
+            "desc": "()I",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "decrementObjectRunningCount",
+            "desc": "()I",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printState",
+            "desc": "(I)Ljava/lang/String;",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getState",
+            "desc": "()I",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "tryUpdateState",
+            "desc": "(II)Z",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 109,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clear",
+            "desc": "()V",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.dataloader.PerLevelDataLoaderDispatchStrategy$CallStack$StateForLevel": {
+        "line": {
+          "covered": 10,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 189,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(II)V",
+            "line": 194,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy$CallStack$StateForLevel;)V",
+            "line": 199,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "copy",
+            "desc": "()Lgraphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy$CallStack$StateForLevel;",
+            "line": 205,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "increaseHappenedCompletionFinishedCount",
+            "desc": "()Lgraphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy$CallStack$StateForLevel;",
+            "line": 209,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "increaseHappenedExecuteObjectCalls",
+            "desc": "()Lgraphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy$CallStack$StateForLevel;",
+            "line": 213,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.dataloader.PerLevelDataLoaderDispatchStrategy$ChainedDLStack$StateForLevel": {
+        "line": {
+          "covered": 7,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lorg/dataloader/DataLoader;ZZZLgraphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy$ChainedDLStack$StateForLevel;)V",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.dataloader.PerLevelDataLoaderDispatchStrategy": {
+        "line": {
+          "covered": 132,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 47,
+          "missed": 3
+        },
+        "method": {
+          "covered": 23,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/ExecutionContext;)V",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executionStrategy",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;I)V",
+            "line": 269,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executionSerialStrategy",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;)V",
+            "line": 278,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executionStrategyOnFieldValuesInfo",
+            "desc": "(Ljava/util/List;Lgraphql/execution/ExecutionStrategyParameters;)V",
+            "line": 288,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executionStrategyOnFieldValuesException",
+            "desc": "(Ljava/lang/Throwable;Lgraphql/execution/ExecutionStrategyParameters;)V",
+            "line": 295,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executeObject",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;I)V",
+            "line": 302,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executeObjectOnFieldValuesInfo",
+            "desc": "(Ljava/util/List;Lgraphql/execution/ExecutionStrategyParameters;)V",
+            "line": 314,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executeObjectOnFieldValuesException",
+            "desc": "(Ljava/lang/Throwable;Lgraphql/execution/ExecutionStrategyParameters;)V",
+            "line": 321,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onCompletionFinished",
+            "desc": "(ILgraphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy$CallStack;)V",
+            "line": 329,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldFetched",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/schema/DataFetcher;Ljava/lang/Object;Ljava/util/function/Supplier;)V",
+            "line": 363,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newSubscriptionExecution",
+            "desc": "(Lgraphql/execution/incremental/AlternativeCallContext;)V",
+            "line": 378,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "subscriptionEventCompletionDone",
+            "desc": "(Lgraphql/execution/incremental/AlternativeCallContext;)V",
+            "line": 385,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deferredOnFieldValue",
+            "desc": "(Ljava/lang/String;Lgraphql/execution/FieldValueInfo;Ljava/lang/Throwable;Lgraphql/execution/ExecutionStrategyParameters;)V",
+            "line": 400,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCallStack",
+            "desc": "(Lgraphql/execution/ExecutionStrategyParameters;)Lgraphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy$CallStack;",
+            "line": 411,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCallStack",
+            "desc": "(Lgraphql/execution/incremental/AlternativeCallContext;)Lgraphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy$CallStack;",
+            "line": 415,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "markLevelAsDispatchedIfReady",
+            "desc": "(ILgraphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy$CallStack;)Z",
+            "line": 450,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isLevelReady",
+            "desc": "(ILgraphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy$CallStack;)Z",
+            "line": 463,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "dispatch",
+            "desc": "(ILgraphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy$CallStack;)V",
+            "line": 473,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "dispatchAll",
+            "desc": "(Lorg/dataloader/DataLoaderRegistry;I)V",
+            "line": 483,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "dispatchDLCFImpl",
+            "desc": "(Ljava/lang/Integer;Lgraphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy$CallStack;ZZ)V",
+            "line": 488,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newDataLoaderInvocation",
+            "desc": "(ILorg/dataloader/DataLoader;Lgraphql/execution/incremental/AlternativeCallContext;)V",
+            "line": 511,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$dispatchDLCFImpl$0",
+            "desc": "(Ljava/lang/Integer;Lgraphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy$CallStack;ZLjava/lang/Void;Ljava/lang/Throwable;)V",
+            "line": 501,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getCallStack$0",
+            "desc": "(Lgraphql/execution/incremental/AlternativeCallContext;)Lgraphql/execution/instrumentation/dataloader/PerLevelDataLoaderDispatchStrategy$CallStack;",
+            "line": 424,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.dataloader.ExhaustedDataLoaderDispatchStrategy": {
+        "line": {
+          "covered": 83,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 26,
+          "missed": 0
+        },
+        "method": {
+          "covered": 18,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/ExecutionContext;)V",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/instrumentation/dataloader/ExhaustedDataLoaderDispatchStrategy$CallStack;)V",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executionStrategy",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;I)V",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "finishedFetching",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;)V",
+            "line": 152,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executionSerialStrategy",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;)V",
+            "line": 158,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newSubscriptionExecution",
+            "desc": "(Lgraphql/execution/incremental/AlternativeCallContext;)V",
+            "line": 165,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "subscriptionEventCompletionDone",
+            "desc": "(Lgraphql/execution/incremental/AlternativeCallContext;)V",
+            "line": 172,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deferFieldFetched",
+            "desc": "(Lgraphql/execution/ExecutionStrategyParameters;)V",
+            "line": 178,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "startComplete",
+            "desc": "(Lgraphql/execution/ExecutionStrategyParameters;)V",
+            "line": 188,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "stopComplete",
+            "desc": "(Lgraphql/execution/ExecutionStrategyParameters;)V",
+            "line": 193,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCallStack",
+            "desc": "(Lgraphql/execution/ExecutionStrategyParameters;)Lgraphql/execution/instrumentation/dataloader/ExhaustedDataLoaderDispatchStrategy$CallStack;",
+            "line": 198,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCallStack",
+            "desc": "(Lgraphql/execution/incremental/AlternativeCallContext;)Lgraphql/execution/instrumentation/dataloader/ExhaustedDataLoaderDispatchStrategy$CallStack;",
+            "line": 202,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "decrementObjectRunningAndMaybeDispatch",
+            "desc": "(Lgraphql/execution/instrumentation/dataloader/ExhaustedDataLoaderDispatchStrategy$CallStack;)V",
+            "line": 220,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newDataLoaderInvocationMaybeDispatch",
+            "desc": "(Lgraphql/execution/instrumentation/dataloader/ExhaustedDataLoaderDispatchStrategy$CallStack;)V",
+            "line": 229,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "dispatchImpl",
+            "desc": "(Lgraphql/execution/instrumentation/dataloader/ExhaustedDataLoaderDispatchStrategy$CallStack;)V",
+            "line": 248,
+            "counters": {
+              "line": {
+                "covered": 20,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newDataLoaderInvocation",
+            "desc": "(Lgraphql/execution/incremental/AlternativeCallContext;)V",
+            "line": 278,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$dispatchImpl$0",
+            "desc": "(Lgraphql/execution/instrumentation/dataloader/ExhaustedDataLoaderDispatchStrategy$CallStack;Ljava/lang/Void;Ljava/lang/Throwable;)V",
+            "line": 271,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getCallStack$0",
+            "desc": "(Lgraphql/execution/incremental/AlternativeCallContext;)Lgraphql/execution/instrumentation/dataloader/ExhaustedDataLoaderDispatchStrategy$CallStack;",
+            "line": 211,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.transform.FieldVisibilitySchemaTransformation$TypeRemovalVisitor": {
+        "line": {
+          "covered": 12,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 18,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Set;)V",
+            "line": 263,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLType",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 271,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 18,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.transform.VisibleFieldPredicateEnvironment$VisibleFieldPredicateEnvironmentImpl": {
+        "line": {
+          "covered": 5,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLNamedSchemaElement;Lgraphql/schema/GraphQLSchemaElement;)V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSchemaElement",
+            "desc": "()Lgraphql/schema/GraphQLNamedSchemaElement;",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParentElement",
+            "desc": "()Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.transform.FieldVisibilitySchemaTransformation$TypeObservingVisitor": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 12,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Set;)V",
+            "line": 157,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLType",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 164,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 12,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.transform.FieldVisibilitySchemaTransformation": {
+        "line": {
+          "covered": 54,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 14,
+          "missed": 0
+        },
+        "method": {
+          "covered": 12,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/transform/VisibleFieldPredicate;)V",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/transform/VisibleFieldPredicate;Ljava/lang/Runnable;Ljava/lang/Runnable;)V",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "apply",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Lgraphql/schema/GraphQLSchema;",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "findRootUnusedTypes",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Ljava/util/Set;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isIntrospectionType",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 133,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "childrenWithInterfaceImplementations",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Ljava/util/function/Function;",
+            "line": 142,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getRootTypes",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Ljava/util/List;",
+            "line": 294,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOperationTypes",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Ljava/util/List;",
+            "line": 301,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$childrenWithInterfaceImplementations$0",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLSchemaElement;)Ljava/util/List;",
+            "line": 143,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$apply$0",
+            "desc": "(Lgraphql/schema/GraphQLType;)Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$1",
+            "desc": "()V",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$0",
+            "desc": "()V",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.transform.FieldVisibilitySchemaTransformation$FieldRemovalVisitor": {
+        "line": {
+          "covered": 33,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 16,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/transform/VisibleFieldPredicate;)V",
+            "line": 181,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLObjectType",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInterfaceType",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 195,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitFieldsContainer",
+            "desc": "(Lgraphql/schema/GraphQLFieldsContainer;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 199,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputObjectType",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 219,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 241,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputObjectField",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 251,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.HungarianAlgorithm": {
+        "line": {
+          "covered": 121,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 75,
+          "missed": 1
+        },
+        "method": {
+          "covered": 11,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "([[D)V",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "computeInitialFeasibleSolution",
+            "desc": "()V",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "execute",
+            "desc": "()[I",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executePhase",
+            "desc": "()V",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 32,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 18,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fetchUnmatchedWorker",
+            "desc": "()I",
+            "line": 257,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "greedyMatch",
+            "desc": "()V",
+            "line": 270,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "initializePhase",
+            "desc": "(I)V",
+            "line": 288,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "match",
+            "desc": "(II)V",
+            "line": 304,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "reduce",
+            "desc": "()V",
+            "line": 315,
+            "counters": {
+              "line": {
+                "covered": 18,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 20,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "updateLabeling",
+            "desc": "(D)V",
+            "line": 352,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "nextChild",
+            "desc": "()[I",
+            "line": 367,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.SchemaDiffingCancelledException": {
+        "line": {
+          "covered": 0,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 2
+        },
+        "method": {
+          "covered": 0,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Z)V",
+            "line": 8,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.SchemaDiffing": {
+        "line": {
+          "covered": 59,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 7,
+          "missed": 1
+        },
+        "method": {
+          "covered": 5,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 21,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "stop",
+            "desc": "()V",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "diffGraphQLSchema",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLSchema;)Ljava/util/List;",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "diffAndAnalyze",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLSchema;)Lgraphql/schema/diffing/ana/EditOperationAnalysisResult;",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "diffGraphQLSchemaAllEdits",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLSchema;Ljava/util/concurrent/atomic/AtomicInteger;)Lgraphql/schema/diffing/DiffImpl$OptimalEdit;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "diffImpl",
+            "desc": "(Lgraphql/schema/diffing/SchemaGraph;Lgraphql/schema/diffing/SchemaGraph;Ljava/util/concurrent/atomic/AtomicInteger;)Lgraphql/schema/diffing/DiffImpl$OptimalEdit;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 46,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sortVertices",
+            "desc": "(Ljava/util/List;Lgraphql/schema/diffing/SchemaGraph;Lgraphql/schema/diffing/PossibleMappingsCalculator$PossibleMappings;)V",
+            "line": 134,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.EditorialCostForMapping": {
+        "line": {
+          "covered": 73,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 60,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 13,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "baseEditorialCostForMapping",
+            "desc": "(Lgraphql/schema/diffing/Mapping;Lgraphql/schema/diffing/SchemaGraph;Lgraphql/schema/diffing/SchemaGraph;)I",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "baseEditorialCostForMapping",
+            "desc": "(Lgraphql/schema/diffing/Mapping;Lgraphql/schema/diffing/SchemaGraph;Lgraphql/schema/diffing/SchemaGraph;Ljava/util/List;)I",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 35,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 30,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "editorialCostForMapping",
+            "desc": "(ILgraphql/schema/diffing/Mapping;Lgraphql/schema/diffing/SchemaGraph;Lgraphql/schema/diffing/SchemaGraph;)I",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$editorialCostForMapping$1",
+            "desc": "(Ljava/util/concurrent/atomic/AtomicInteger;Lgraphql/schema/diffing/SchemaGraph;Ljava/util/function/Predicate;Lgraphql/schema/diffing/Mapping;Lgraphql/schema/diffing/SchemaGraph;Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/Vertex;)V",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 28,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 28,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$editorialCostForMapping$0",
+            "desc": "(Ljava/util/Set;Lgraphql/schema/diffing/Edge;)Z",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.Vertex": {
+        "line": {
+          "covered": 26,
+          "missed": 7
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 6
+        },
+        "method": {
+          "covered": 12,
+          "missed": 5
+        },
+        "methods": [
+          {
+            "name": "newIsolatedNode",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/diffing/Vertex;",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newIsolatedNodes",
+            "desc": "(ILjava/lang/String;)Ljava/util/Set;",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isIsolated",
+            "desc": "()Z",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "add",
+            "desc": "(Ljava/lang/String;Ljava/lang/Object;)V",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getType",
+            "desc": "()Ljava/lang/String;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "get",
+            "desc": "(Ljava/lang/String;)Ljava/lang/Object;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getProperty",
+            "desc": "(Ljava/lang/String;)Ljava/lang/Object;",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getProperties",
+            "desc": "()Ljava/util/Map;",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDebugName",
+            "desc": "()Ljava/lang/String;",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isOfType",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Z",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 6
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isBuiltInType",
+            "desc": "()Z",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "setBuiltInType",
+            "desc": "(Z)V",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toData",
+            "desc": "()Lgraphql/schema/diffing/Vertex$VertexData;",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.EditOperation$Operation": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.SchemaGraphFactory$1": {
+        "line": {
+          "covered": 24,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 22,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/diffing/SchemaGraphFactory;Lgraphql/schema/diffing/SchemaGraph;)V",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enter",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 22,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 22,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "leave",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.SchemaDiffingRunningCheck": {
+        "line": {
+          "covered": 4,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 1,
+          "missed": 1
+        },
+        "method": {
+          "covered": 2,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 5,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "check",
+            "desc": "()V",
+            "line": 9,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "stop",
+            "desc": "()V",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.EditOperation": {
+        "line": {
+          "covered": 20,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 13,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/diffing/EditOperation$Operation;Ljava/lang/String;Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/Edge;Lgraphql/schema/diffing/Edge;)V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deleteVertex",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/Vertex;)Lgraphql/schema/diffing/EditOperation;",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "insertVertex",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/Vertex;)Lgraphql/schema/diffing/EditOperation;",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "changeVertex",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/Vertex;)Lgraphql/schema/diffing/EditOperation;",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deleteEdge",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/Edge;)Lgraphql/schema/diffing/EditOperation;",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "insertEdge",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/Edge;)Lgraphql/schema/diffing/EditOperation;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "changeEdge",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/Edge;Lgraphql/schema/diffing/Edge;)Lgraphql/schema/diffing/EditOperation;",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOperation",
+            "desc": "()Lgraphql/schema/diffing/EditOperation$Operation;",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSourceVertex",
+            "desc": "()Lgraphql/schema/diffing/Vertex;",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTargetVertex",
+            "desc": "()Lgraphql/schema/diffing/Vertex;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSourceEdge",
+            "desc": "()Lgraphql/schema/diffing/Edge;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTargetEdge",
+            "desc": "()Lgraphql/schema/diffing/Edge;",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.Util": {
+        "line": {
+          "covered": 10,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 8,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 9,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "diffNamedList",
+            "desc": "(Ljava/util/Set;Ljava/util/Set;Ljava/util/List;Ljava/util/List;Ljava/util/List;)V",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$PossibleMappings": {
+        "line": {
+          "covered": 77,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 32,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/diffing/PossibleMappingsCalculator;)V",
+            "line": 805,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "putPossibleMappings",
+            "desc": "(Ljava/util/List;Ljava/util/Collection;Ljava/util/Collection;Ljava/lang/String;)V",
+            "line": 822,
+            "counters": {
+              "line": {
+                "covered": 68,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 32,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mappingPossible",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/Vertex;)Z",
+            "line": 924,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator": {
+        "line": {
+          "covered": 201,
+          "missed": 8
+        },
+        "branch": {
+          "covered": 45,
+          "missed": 19
+        },
+        "method": {
+          "covered": 30,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "inputFieldContexts",
+            "desc": "()Ljava/util/List;",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "scalarContext",
+            "desc": "()Ljava/util/List;",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inputObjectContext",
+            "desc": "()Ljava/util/List;",
+            "line": 152,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "objectContext",
+            "desc": "()Ljava/util/List;",
+            "line": 179,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enumContext",
+            "desc": "()Ljava/util/List;",
+            "line": 207,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enumValueContext",
+            "desc": "()Ljava/util/List;",
+            "line": 234,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "interfaceContext",
+            "desc": "()Ljava/util/List;",
+            "line": 272,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unionContext",
+            "desc": "()Ljava/util/List;",
+            "line": 300,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "directiveContext",
+            "desc": "()Ljava/util/List;",
+            "line": 328,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "appliedDirectiveContext",
+            "desc": "()Ljava/util/List;",
+            "line": 356,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "appliedArgumentContext",
+            "desc": "()Ljava/util/List;",
+            "line": 494,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "schemaContext",
+            "desc": "()Ljava/util/List;",
+            "line": 639,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldContext",
+            "desc": "()Ljava/util/List;",
+            "line": 654,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "argumentsContexts",
+            "desc": "()Ljava/util/List;",
+            "line": 695,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/diffing/SchemaGraph;Lgraphql/schema/diffing/SchemaGraph;Lgraphql/schema/diffing/SchemaDiffingRunningCheck;)V",
+            "line": 754,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "calculate",
+            "desc": "()Lgraphql/schema/diffing/PossibleMappingsCalculator$PossibleMappings;",
+            "line": 762,
+            "counters": {
+              "line": {
+                "covered": 22,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "calcPossibleMappings",
+            "desc": "(Ljava/util/List;Ljava/lang/String;)V",
+            "line": 930,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "calcPossibleMappingImpl",
+            "desc": "(Ljava/util/Collection;Ljava/util/Collection;Ljava/util/List;ILjava/util/List;Ljava/util/Set;Ljava/util/Set;Ljava/lang/String;)V",
+            "line": 954,
+            "counters": {
+              "line": {
+                "covered": 44,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 16,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFixedParentRestrictions",
+            "desc": "()Ljava/util/Map;",
+            "line": 1024,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFixedParentRestrictionsInverse",
+            "desc": "(Ljava/util/Map;)Ljava/util/Map;",
+            "line": 1032,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFixedParentRestrictions",
+            "desc": "(Lgraphql/schema/diffing/SchemaGraph;Ljava/util/List;Ljava/util/Map;)Ljava/util/Map;",
+            "line": 1054,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNonFixedParentRestrictions",
+            "desc": "(Lgraphql/schema/diffing/SchemaGraph;Lgraphql/schema/diffing/SchemaGraph;Lgraphql/schema/diffing/Mapping;)Ljava/util/Map;",
+            "line": 1102,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasParentRestrictions",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Z",
+            "line": 1131,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasChildrenRestrictions",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Z",
+            "line": 1138,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 4
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getNonFixedParentRestrictions$0",
+            "desc": "(Lgraphql/schema/diffing/SchemaGraph;Ljava/util/Map;Lgraphql/schema/diffing/SchemaGraph;Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/Vertex;)V",
+            "line": 1105,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 8
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 11
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$calcPossibleMappingImpl$3",
+            "desc": "(Lgraphql/schema/diffing/PossibleMappingsCalculator$VertexContextSegment;Lgraphql/schema/diffing/Vertex;)Ljava/lang/String;",
+            "line": 962,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$calcPossibleMappingImpl$2",
+            "desc": "(Lgraphql/schema/diffing/PossibleMappingsCalculator$VertexContextSegment;Lgraphql/schema/diffing/Vertex;)Z",
+            "line": 961,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$calcPossibleMappingImpl$1",
+            "desc": "(Lgraphql/schema/diffing/PossibleMappingsCalculator$VertexContextSegment;Lgraphql/schema/diffing/Vertex;)Ljava/lang/String;",
+            "line": 959,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$calcPossibleMappingImpl$0",
+            "desc": "(Lgraphql/schema/diffing/PossibleMappingsCalculator$VertexContextSegment;Lgraphql/schema/diffing/Vertex;)Z",
+            "line": 958,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$1": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.DiffImpl$MappingEntry": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/diffing/Mapping;ID)V",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$5": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 144,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$4": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 128,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 133,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$3": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$2": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$9": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 191,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 194,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 199,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$8": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 179,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 182,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 187,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$7": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 166,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 171,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$6": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 152,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 155,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 160,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.DiffImpl": {
+        "line": {
+          "covered": 196,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 93,
+          "missed": 15
+        },
+        "method": {
+          "covered": 11,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/diffing/PossibleMappingsCalculator;Lgraphql/schema/diffing/SchemaGraph;Lgraphql/schema/diffing/SchemaGraph;Lgraphql/schema/diffing/PossibleMappingsCalculator$PossibleMappings;Lgraphql/schema/diffing/SchemaDiffingRunningCheck;)V",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "diffImpl",
+            "desc": "(Lgraphql/schema/diffing/Mapping;Ljava/util/List;Ljava/util/List;Ljava/util/concurrent/atomic/AtomicInteger;)Lgraphql/schema/diffing/DiffImpl$OptimalEdit;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 22,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addChildToQueue",
+            "desc": "(ILgraphql/schema/diffing/DiffImpl$MappingEntry;Ljava/util/PriorityQueue;Lgraphql/schema/diffing/DiffImpl$OptimalEdit;Ljava/util/List;Ljava/util/List;)V",
+            "line": 185,
+            "counters": {
+              "line": {
+                "covered": 43,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 11,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "updateOptimalEdit",
+            "desc": "(Lgraphql/schema/diffing/DiffImpl$OptimalEdit;ILgraphql/schema/diffing/Mapping;)V",
+            "line": 267,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "calculateRestOfChildren",
+            "desc": "(Ljava/util/List;Lgraphql/schema/diffing/HungarianAlgorithm;[[DDLgraphql/schema/diffing/Mapping;Lgraphql/schema/diffing/Vertex;IILjava/util/concurrent/LinkedBlockingQueue;)V",
+            "line": 284,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addSiblingToQueue",
+            "desc": "(IILjava/util/PriorityQueue;Lgraphql/schema/diffing/DiffImpl$OptimalEdit;Ljava/util/List;Ljava/util/List;Lgraphql/schema/diffing/DiffImpl$MappingEntry;)V",
+            "line": 319,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "expandMappingAndUpdateOptimalMapping",
+            "desc": "(IILgraphql/schema/diffing/DiffImpl$OptimalEdit;Ljava/util/List;Lgraphql/schema/diffing/Mapping;[ILjava/util/List;D)V",
+            "line": 352,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCostMatrixSum",
+            "desc": "([[D[I)D",
+            "line": 365,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "calcLowerBoundMappingCost",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/Mapping;Ljava/util/Map;Ljava/util/Map;)D",
+            "line": 406,
+            "counters": {
+              "line": {
+                "covered": 73,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 53,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "calcLowerBoundMappingCostForIsolated",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/Mapping;Z)D",
+            "line": 543,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$diffImpl$0",
+            "desc": "(Lgraphql/schema/diffing/DiffImpl$MappingEntry;Lgraphql/schema/diffing/DiffImpl$MappingEntry;)I",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.Edge": {
+        "line": {
+          "covered": 16,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/Vertex;)V",
+            "line": 12,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/Vertex;Ljava/lang/String;)V",
+            "line": 12,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFrom",
+            "desc": "()Lgraphql/schema/diffing/Vertex;",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setFrom",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)V",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getTo",
+            "desc": "()Lgraphql/schema/diffing/Vertex;",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setTo",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)V",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "setLabel",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLabel",
+            "desc": "()Ljava/lang/String;",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Lgraphql/schema/diffing/Edge;)Z",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$41": {
+        "line": {
+          "covered": 7,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 719,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 722,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 735,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$40": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 707,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 710,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 716,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$42": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 738,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 741,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 746,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$30": {
+        "line": {
+          "covered": 4,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 519,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 522,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 529,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$34": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/diffing/PossibleMappingsCalculator$VertexContextSegment;Lgraphql/schema/diffing/PossibleMappingsCalculator$VertexContextSegment;Lgraphql/schema/diffing/PossibleMappingsCalculator$VertexContextSegment;Lgraphql/schema/diffing/PossibleMappingsCalculator$VertexContextSegment;)V",
+            "line": 624,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 627,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$33": {
+        "line": {
+          "covered": 2,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 613,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 616,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 621,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$32": {
+        "line": {
+          "covered": 1,
+          "missed": 12
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 6
+        },
+        "method": {
+          "covered": 1,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 575,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 578,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 11
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 6
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 610,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$31": {
+        "line": {
+          "covered": 19,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 11,
+          "missed": 1
+        },
+        "method": {
+          "covered": 2,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 532,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 535,
+            "counters": {
+              "line": {
+                "covered": 18,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 11,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 571,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$38": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 678,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 681,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 686,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$37": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 665,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 668,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 674,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$36": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 654,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 657,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 662,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$35": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 639,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 642,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 647,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$39": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 695,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 698,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 703,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$23": {
+        "line": {
+          "covered": 2,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 376,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 379,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 384,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$22": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 367,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 370,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$21": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 356,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 359,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 364,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$20": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 339,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 342,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 347,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$27": {
+        "line": {
+          "covered": 5,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/diffing/PossibleMappingsCalculator$VertexContextSegment;Lgraphql/schema/diffing/PossibleMappingsCalculator$VertexContextSegment;Lgraphql/schema/diffing/PossibleMappingsCalculator$VertexContextSegment;Lgraphql/schema/diffing/PossibleMappingsCalculator$VertexContextSegment;)V",
+            "line": 479,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 482,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$26": {
+        "line": {
+          "covered": 9,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 2
+        },
+        "method": {
+          "covered": 2,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 442,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 445,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 476,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$25": {
+        "line": {
+          "covered": 18,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 11,
+          "missed": 1
+        },
+        "method": {
+          "covered": 2,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 400,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 403,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 11,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 438,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$24": {
+        "line": {
+          "covered": 3,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 388,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 391,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 397,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$29": {
+        "line": {
+          "covered": 4,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 505,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 508,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 515,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$28": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 494,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 497,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 502,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$VertexContextSegment": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 795,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 801,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$12": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 234,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 237,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 242,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$11": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 218,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 221,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 226,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$10": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 207,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 210,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 215,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$16": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 283,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 286,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 291,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$15": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 272,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 275,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 280,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$14": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 256,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 259,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 264,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$13": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 245,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 248,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 253,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$19": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 328,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 331,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 336,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$18": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 311,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 314,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 319,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.PossibleMappingsCalculator$17": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 300,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "idForVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Ljava/lang/String;",
+            "line": 303,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 308,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.SchemaGraph": {
+        "line": {
+          "covered": 81,
+          "missed": 44
+        },
+        "branch": {
+          "covered": 19,
+          "missed": 31
+        },
+        "method": {
+          "covered": 35,
+          "missed": 11
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;Ljava/util/List;Lcom/google/common/collect/Table;)V",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 12
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "addVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)V",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addVertices",
+            "desc": "(Ljava/util/Collection;)V",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getVerticesByType",
+            "desc": "(Ljava/lang/String;)Ljava/util/Collection;",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getVerticesByType",
+            "desc": "()Lcom/google/common/collect/Multimap;",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addEdge",
+            "desc": "(Lgraphql/schema/diffing/Edge;)V",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAdjacentEdgesNonCopy",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Ljava/util/Collection;",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAdjacentEdgesAndInverseNonCopy",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Ljava/lang/Iterable;",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "adjacentEdgesAndInverseCount",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)I",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAdjacentVertices",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Ljava/util/List;",
+            "line": 106,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getAdjacentVertices",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Ljava/util/function/Predicate;)Ljava/util/List;",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 7
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 4
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getAdjacentVerticesInverse",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Ljava/util/List;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAdjacentVerticesInverse",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Ljava/util/function/Predicate;)Ljava/util/List;",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAdjacentEdges",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Ljava/util/List;",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAdjacentEdges",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Ljava/util/function/Predicate;)Ljava/util/List;",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAdjacentEdgesInverseCopied",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Ljava/util/List;",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAdjacentEdgesInverseNonCopy",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Ljava/util/Collection;",
+            "line": 154,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAdjacentEdgesInverse",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Ljava/util/function/Predicate;)Ljava/util/List;",
+            "line": 158,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 7
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 4
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getSingleAdjacentEdge",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Ljava/util/function/Predicate;)Lgraphql/schema/diffing/Edge;",
+            "line": 169,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 5
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 4
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getEdges",
+            "desc": "()Ljava/util/List;",
+            "line": 178,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getEdge",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/Vertex;)Lgraphql/schema/diffing/Edge;",
+            "line": 183,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getEdgeOrInverse",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/Vertex;)Lgraphql/schema/diffing/Edge;",
+            "line": 187,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getVertices",
+            "desc": "()Ljava/util/List;",
+            "line": 192,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setVertices",
+            "desc": "(Ljava/util/List;)V",
+            "line": 196,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "addType",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/Vertex;)V",
+            "line": 200,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addDirective",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/diffing/Vertex;)V",
+            "line": 204,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getType",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/diffing/Vertex;",
+            "line": 208,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/diffing/Vertex;",
+            "line": 212,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "findTargetVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Ljava/util/function/Predicate;)Ljava/util/Optional;",
+            "line": 216,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "size",
+            "desc": "()I",
+            "line": 220,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addIsolatedVertices",
+            "desc": "(ILjava/lang/String;)Ljava/util/List;",
+            "line": 224,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 6
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getFieldOrDirectiveForArgument",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Lgraphql/schema/diffing/Vertex;",
+            "line": 234,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldsContainerForField",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Lgraphql/schema/diffing/Vertex;",
+            "line": 240,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInputObjectForInputField",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Lgraphql/schema/diffing/Vertex;",
+            "line": 246,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirectiveForAppliedArgument",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Lgraphql/schema/diffing/Vertex;",
+            "line": 252,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirectiveContainerForAppliedDirective",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Lgraphql/schema/diffing/Vertex;",
+            "line": 258,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSingleAdjacentInverseVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Lgraphql/schema/diffing/Vertex;",
+            "line": 270,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirectiveIndex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)I",
+            "line": 276,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getEnumForEnumValue",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Lgraphql/schema/diffing/Vertex;",
+            "line": 282,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllAdjacentEdges",
+            "desc": "(Ljava/util/List;Lgraphql/schema/diffing/Vertex;)Ljava/util/List;",
+            "line": 289,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 8
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 4
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "containsEdge",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/Vertex;)Z",
+            "line": 301,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$containsEdge$0",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/Edge;)Z",
+            "line": 301,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getAdjacentEdges$0",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Z",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getAdjacentVerticesInverse$0",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Z",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getAdjacentVertices$0",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Z",
+            "line": 106,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.Vertex$VertexData": {
+        "line": {
+          "covered": 0,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 0,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/Map;)V",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.SchemaGraphFactory": {
+        "line": {
+          "covered": 258,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 73,
+          "missed": 7
+        },
+        "method": {
+          "covered": 29,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createGraph",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Lgraphql/schema/diffing/SchemaGraph;",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 27,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 15,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addSchemaVertex",
+            "desc": "(Lgraphql/schema/diffing/SchemaGraph;Lgraphql/schema/GraphQLSchema;)V",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleInputObject",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;Lgraphql/schema/GraphQLSchema;)V",
+            "line": 147,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleInputField",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/GraphQLInputObjectField;Lgraphql/schema/diffing/SchemaGraph;Lgraphql/schema/GraphQLSchema;)V",
+            "line": 158,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleUnion",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;Lgraphql/schema/GraphQLSchema;)V",
+            "line": 172,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleInterfaceVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;Lgraphql/schema/GraphQLSchema;)V",
+            "line": 181,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleObjectVertex",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;Lgraphql/schema/GraphQLSchema;)V",
+            "line": 198,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleField",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/diffing/SchemaGraph;Lgraphql/schema/GraphQLSchema;)V",
+            "line": 215,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleDirective",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/SchemaGraph;Lgraphql/schema/GraphQLSchema;)V",
+            "line": 230,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleArgument",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/GraphQLArgument;Lgraphql/schema/diffing/SchemaGraph;)V",
+            "line": 240,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newObject",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/schema/diffing/SchemaGraph;Z)V",
+            "line": 253,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newField",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/diffing/SchemaGraph;Z)Lgraphql/schema/diffing/Vertex;",
+            "line": 268,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newArgument",
+            "desc": "(Lgraphql/schema/GraphQLArgument;Lgraphql/schema/diffing/SchemaGraph;Z)Lgraphql/schema/diffing/Vertex;",
+            "line": 282,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newScalar",
+            "desc": "(Lgraphql/schema/GraphQLScalarType;Lgraphql/schema/diffing/SchemaGraph;Z)V",
+            "line": 291,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newInterface",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;Lgraphql/schema/diffing/SchemaGraph;Z)V",
+            "line": 305,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newEnum",
+            "desc": "(Lgraphql/schema/GraphQLEnumType;Lgraphql/schema/diffing/SchemaGraph;Z)V",
+            "line": 320,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newUnion",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;Lgraphql/schema/diffing/SchemaGraph;Z)V",
+            "line": 338,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newInputObject",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;Lgraphql/schema/diffing/SchemaGraph;Z)V",
+            "line": 348,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createAppliedDirectives",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Ljava/util/List;Lgraphql/schema/diffing/SchemaGraph;)V",
+            "line": 365,
+            "counters": {
+              "line": {
+                "covered": 18,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;Lgraphql/schema/diffing/SchemaGraph;)V",
+            "line": 389,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newInputField",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;Lgraphql/schema/diffing/SchemaGraph;Z)Lgraphql/schema/diffing/Vertex;",
+            "line": 406,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "desc",
+            "desc": "(Ljava/lang/String;)Ljava/lang/String;",
+            "line": 416,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$handleDirective$0",
+            "desc": "(Lgraphql/schema/GraphQLArgument;Lgraphql/schema/diffing/Vertex;)Z",
+            "line": 232,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$handleField$0",
+            "desc": "(Lgraphql/schema/GraphQLArgument;Lgraphql/schema/diffing/Vertex;)Z",
+            "line": 223,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$handleObjectVertex$0",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/diffing/Vertex;)Z",
+            "line": 207,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$handleInterfaceVertex$0",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/diffing/Vertex;)Z",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$handleInputObject$0",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;Lgraphql/schema/diffing/Vertex;)Z",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.Mapping": {
+        "line": {
+          "covered": 73,
+          "missed": 8
+        },
+        "branch": {
+          "covered": 21,
+          "missed": 3
+        },
+        "method": {
+          "covered": 19,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Map;Lcom/google/common/collect/BiMap;Ljava/util/List;Ljava/util/List;Lcom/google/common/collect/BiMap;Ljava/util/List;Ljava/util/List;)V",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newMapping",
+            "desc": "(Ljava/util/Map;Lcom/google/common/collect/BiMap;Ljava/util/List;Ljava/util/List;)Lgraphql/schema/diffing/Mapping;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasParentRestriction",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Z",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParentRestriction",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Lgraphql/schema/diffing/Vertex;",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSource",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Lgraphql/schema/diffing/Vertex;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTarget",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Lgraphql/schema/diffing/Vertex;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSource",
+            "desc": "(I)Lgraphql/schema/diffing/Vertex;",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTarget",
+            "desc": "(I)Lgraphql/schema/diffing/Vertex;",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "containsSource",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Z",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "containsTarget",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Z",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "contains",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Z)Z",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "size",
+            "desc": "()I",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fixedSize",
+            "desc": "()I",
+            "line": 124,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "nonFixedSize",
+            "desc": "()I",
+            "line": 128,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "add",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/Vertex;)V",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "copyMappingWithLastElementRemoved",
+            "desc": "()Lgraphql/schema/diffing/Mapping;",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "copy",
+            "desc": "()Lgraphql/schema/diffing/Mapping;",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "extendMapping",
+            "desc": "(Lgraphql/schema/diffing/Vertex;Lgraphql/schema/diffing/Vertex;)Lgraphql/schema/diffing/Mapping;",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "forEachTarget",
+            "desc": "(Ljava/util/function/Consumer;)V",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "forEachNonFixedTarget",
+            "desc": "(Ljava/util/function/Consumer;)V",
+            "line": 172,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "forEachNonFixedSourceAndTarget",
+            "desc": "(Ljava/util/function/BiConsumer;)V",
+            "line": 178,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "invert",
+            "desc": "()Lgraphql/schema/diffing/Mapping;",
+            "line": 182,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.SchemaGraphFactory$1IntrospectionNode": {
+        "line": {
+          "covered": 1,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/diffing/SchemaGraphFactory;)V",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diffing.DiffImpl$OptimalEdit": {
+        "line": {
+          "covered": 14,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 1,
+          "missed": 1
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/diffing/SchemaGraph;Lgraphql/schema/diffing/SchemaGraph;)V",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/diffing/SchemaGraph;Lgraphql/schema/diffing/SchemaGraph;Lgraphql/schema/diffing/Mapping;I)V",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getListOfEditOperations",
+            "desc": "()Ljava/util/List;",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.scalar.GraphqlFloatCoercing": {
+        "line": {
+          "covered": 38,
+          "missed": 7
+        },
+        "branch": {
+          "covered": 17,
+          "missed": 3
+        },
+        "method": {
+          "covered": 11,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "convertImpl",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Double;",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "serialiseImpl",
+            "desc": "(Ljava/lang/Object;Ljava/util/Locale;)Ljava/lang/Double;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseValueImpl",
+            "desc": "(Ljava/lang/Object;Ljava/util/Locale;)Ljava/lang/Double;",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseLiteralImpl",
+            "desc": "(Ljava/lang/Object;Ljava/util/Locale;)D",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "valueToLiteralImpl",
+            "desc": "(Ljava/lang/Object;Ljava/util/Locale;)Lgraphql/language/FloatValue;",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "serialize",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Double;",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "serialize",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Double;",
+            "line": 113,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseValue",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Double;",
+            "line": 119,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseValue",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Double;",
+            "line": 124,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseLiteral",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Double;",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseLiteral",
+            "desc": "(Lgraphql/language/Value;Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Double;",
+            "line": 135,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "valueToLiteral",
+            "desc": "(Ljava/lang/Object;)Lgraphql/language/Value;",
+            "line": 141,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "valueToLiteral",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Lgraphql/language/Value;",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.scalar.CoercingUtil": {
+        "line": {
+          "covered": 4,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 5,
+          "missed": 1
+        },
+        "method": {
+          "covered": 3,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 9,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isNumberIsh",
+            "desc": "(Ljava/lang/Object;)Z",
+            "line": 11,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "typeName",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/String;",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "i18nMsg",
+            "desc": "(Ljava/util/Locale;Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.scalar.GraphqlIDCoercing": {
+        "line": {
+          "covered": 34,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 17,
+          "missed": 3
+        },
+        "method": {
+          "covered": 13,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "convertImpl",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/String;",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "serializeImpl",
+            "desc": "(Ljava/lang/Object;Ljava/util/Locale;)Ljava/lang/String;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseValueImpl",
+            "desc": "(Ljava/lang/Object;Ljava/util/Locale;)Ljava/lang/String;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseLiteralImpl",
+            "desc": "(Ljava/lang/Object;Ljava/util/Locale;)Ljava/lang/String;",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "valueToLiteralImpl",
+            "desc": "(Ljava/lang/Object;Ljava/util/Locale;)Lgraphql/language/StringValue;",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "serialize",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/String;",
+            "line": 97,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "serialize",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseValue",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/String;",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseValue",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 113,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseLiteral",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/String;",
+            "line": 119,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseLiteral",
+            "desc": "(Lgraphql/language/Value;Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 124,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "valueToLiteral",
+            "desc": "(Ljava/lang/Object;)Lgraphql/language/Value;",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "valueToLiteral",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Lgraphql/language/Value;",
+            "line": 135,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.scalar.GraphqlIntCoercing": {
+        "line": {
+          "covered": 55,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 23,
+          "missed": 1
+        },
+        "method": {
+          "covered": 15,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "convertImpl",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Integer;",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "serialiseImpl",
+            "desc": "(Ljava/lang/Object;Ljava/util/Locale;)Ljava/lang/Integer;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseValueImpl",
+            "desc": "(Ljava/lang/Object;Ljava/util/Locale;)Ljava/lang/Integer;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "convertParseValueImpl",
+            "desc": "(Ljava/lang/Object;)Ljava/math/BigInteger;",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseLiteralImpl",
+            "desc": "(Ljava/lang/Object;Ljava/util/Locale;)I",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "valueToLiteralImpl",
+            "desc": "(Ljava/lang/Object;Ljava/util/Locale;)Lgraphql/language/IntValue;",
+            "line": 123,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "serialize",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Integer;",
+            "line": 134,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "serialize",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Integer;",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseValue",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Integer;",
+            "line": 145,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseValue",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Integer;",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseLiteral",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Integer;",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseLiteral",
+            "desc": "(Lgraphql/language/Value;Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Integer;",
+            "line": 161,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "valueToLiteral",
+            "desc": "(Ljava/lang/Object;)Lgraphql/language/Value;",
+            "line": 167,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "valueToLiteral",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Lgraphql/language/Value;",
+            "line": 172,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.scalar.GraphqlStringCoercing": {
+        "line": {
+          "covered": 18,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 12,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toStringImpl",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/String;",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseValueImpl",
+            "desc": "(Ljava/lang/Object;Ljava/util/Locale;)Ljava/lang/String;",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseLiteralImpl",
+            "desc": "(Ljava/lang/Object;Ljava/util/Locale;)Ljava/lang/String;",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "valueToLiteralImpl",
+            "desc": "(Ljava/lang/Object;)Lgraphql/language/StringValue;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "serialize",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/String;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "serialize",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/String;",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseValue",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/String;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseValue",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/String;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseLiteral",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/String;",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseLiteral",
+            "desc": "(Lgraphql/language/Value;Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/String;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "valueToLiteral",
+            "desc": "(Ljava/lang/Object;)Lgraphql/language/Value;",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "valueToLiteral",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Lgraphql/language/Value;",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.scalar.GraphqlBooleanCoercing": {
+        "line": {
+          "covered": 38,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 19,
+          "missed": 1
+        },
+        "method": {
+          "covered": 13,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "convertImpl",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Boolean;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 12,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "serializeImpl",
+            "desc": "(Ljava/lang/Object;Ljava/util/Locale;)Ljava/lang/Boolean;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseValueImpl",
+            "desc": "(Ljava/lang/Object;Ljava/util/Locale;)Ljava/lang/Boolean;",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseLiteralImpl",
+            "desc": "(Ljava/lang/Object;Ljava/util/Locale;)Z",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "valueToLiteralImpl",
+            "desc": "(Ljava/lang/Object;Ljava/util/Locale;)Lgraphql/language/BooleanValue;",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "serialize",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Boolean;",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "serialize",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Boolean;",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseValue",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Boolean;",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseValue",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Boolean;",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseLiteral",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Boolean;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseLiteral",
+            "desc": "(Lgraphql/language/Value;Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Boolean;",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "valueToLiteral",
+            "desc": "(Ljava/lang/Object;)Lgraphql/language/Value;",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "valueToLiteral",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Lgraphql/language/Value;",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.nf.NormalizedDocumentFactory$Options": {
+        "line": {
+          "covered": 12,
+          "missed": 9
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 8
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/GraphQLContext;Ljava/util/Locale;IIZ)V",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setDefaultOptions",
+            "desc": "(Lgraphql/normalized/nf/NormalizedDocumentFactory$Options;)V",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "defaultOptions",
+            "desc": "()Lgraphql/normalized/nf/NormalizedDocumentFactory$Options;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "locale",
+            "desc": "(Ljava/util/Locale;)Lgraphql/normalized/nf/NormalizedDocumentFactory$Options;",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "graphQLContext",
+            "desc": "(Lgraphql/GraphQLContext;)Lgraphql/normalized/nf/NormalizedDocumentFactory$Options;",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "maxChildrenDepth",
+            "desc": "(I)Lgraphql/normalized/nf/NormalizedDocumentFactory$Options;",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "maxFieldsCount",
+            "desc": "(I)Lgraphql/normalized/nf/NormalizedDocumentFactory$Options;",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "deferSupport",
+            "desc": "(Z)Lgraphql/normalized/nf/NormalizedDocumentFactory$Options;",
+            "line": 174,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getGraphQLContext",
+            "desc": "()Lgraphql/GraphQLContext;",
+            "line": 183,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getLocale",
+            "desc": "()Ljava/util/Locale;",
+            "line": 192,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getMaxChildrenDepth",
+            "desc": "()I",
+            "line": 201,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMaxFieldsCount",
+            "desc": "()I",
+            "line": 205,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.nf.NormalizedField$Builder": {
+        "line": {
+          "covered": 23,
+          "missed": 20
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 4
+        },
+        "method": {
+          "covered": 9,
+          "missed": 5
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 588,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/normalized/nf/NormalizedField;)V",
+            "line": 588,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 17
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "clearObjectTypesNames",
+            "desc": "()Lgraphql/normalized/nf/NormalizedField$Builder;",
+            "line": 616,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "objectTypeNames",
+            "desc": "(Ljava/util/List;)Lgraphql/normalized/nf/NormalizedField$Builder;",
+            "line": 621,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "alias",
+            "desc": "(Ljava/lang/String;)Lgraphql/normalized/nf/NormalizedField$Builder;",
+            "line": 626,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "normalizedArguments",
+            "desc": "(Ljava/util/Map;)Lgraphql/normalized/nf/NormalizedField$Builder;",
+            "line": 631,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "resolvedArguments",
+            "desc": "(Ljava/util/Map;)Lgraphql/normalized/nf/NormalizedField$Builder;",
+            "line": 636,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "astArguments",
+            "desc": "(Ljava/util/List;)Lgraphql/normalized/nf/NormalizedField$Builder;",
+            "line": 641,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "astDirectives",
+            "desc": "(Ljava/util/List;)Lgraphql/normalized/nf/NormalizedField$Builder;",
+            "line": 646,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldName",
+            "desc": "(Ljava/lang/String;)Lgraphql/normalized/nf/NormalizedField$Builder;",
+            "line": 652,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "children",
+            "desc": "(Ljava/util/List;)Lgraphql/normalized/nf/NormalizedField$Builder;",
+            "line": 658,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "level",
+            "desc": "(I)Lgraphql/normalized/nf/NormalizedField$Builder;",
+            "line": 664,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parent",
+            "desc": "(Lgraphql/normalized/nf/NormalizedField;)Lgraphql/normalized/nf/NormalizedField$Builder;",
+            "line": 669,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/normalized/nf/NormalizedField;",
+            "line": 675,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.nf.NormalizedOperationToAstCompiler": {
+        "line": {
+          "covered": 63,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 11,
+          "missed": 3
+        },
+        "method": {
+          "covered": 14,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "compileToDocument",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLObjectType;Ljava/util/List;Ljava/lang/String;Lgraphql/language/OperationDefinition$Operation;)Lgraphql/normalized/nf/NormalizedOperationToAstCompiler$CompilerResult;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "compileToDocument",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLObjectType;Lgraphql/normalized/nf/NormalizedField;Ljava/lang/String;Lgraphql/language/OperationDefinition$Operation;)Lgraphql/normalized/nf/NormalizedOperationToAstCompiler$CompilerResult;",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "compileToDocument",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/normalized/nf/NormalizedOperation;)Lgraphql/normalized/nf/NormalizedOperationToAstCompiler$CompilerResult;",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "compileToDocumentImpl",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLObjectType;Ljava/util/List;Ljava/lang/String;Lgraphql/language/OperationDefinition$Operation;)Lgraphql/normalized/nf/NormalizedOperationToAstCompiler$CompilerResult;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "subSelectionsForNormalizedFields",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Ljava/lang/String;Ljava/util/List;)Ljava/util/List;",
+            "line": 135,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "selectionForNormalizedField",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/normalized/nf/NormalizedField;)Ljava/util/Map;",
+            "line": 171,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "selectionForNormalizedField",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Ljava/lang/String;Lgraphql/normalized/nf/NormalizedField;)Lgraphql/language/Field;",
+            "line": 188,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "selectionSetOrNullIfEmpty",
+            "desc": "(Ljava/util/List;)Lgraphql/language/SelectionSet;",
+            "line": 218,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "selectionSet",
+            "desc": "(Ljava/util/List;)Lgraphql/language/SelectionSet;",
+            "line": 222,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Ljava/lang/String;Lgraphql/normalized/nf/NormalizedField;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 230,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOperationType",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/OperationDefinition$Operation;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 236,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$subSelectionsForNormalizedFields$2",
+            "desc": "(Lcom/google/common/collect/ImmutableList$Builder;Ljava/lang/String;Ljava/util/List;)V",
+            "line": 154,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$subSelectionsForNormalizedFields$0",
+            "desc": "(Ljava/util/Map;Ljava/lang/String;Lgraphql/language/Field;)V",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$subSelectionsForNormalizedFields$1",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.nf.NormalizedField": {
+        "line": {
+          "covered": 88,
+          "missed": 76
+        },
+        "branch": {
+          "covered": 38,
+          "missed": 32
+        },
+        "method": {
+          "covered": 25,
+          "missed": 24
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/normalized/nf/NormalizedField$Builder;)V",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isConditional",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Z",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 18,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 16,
+                "missed": 8
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasChildren",
+            "desc": "()Z",
+            "line": 179,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getType",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Lgraphql/schema/GraphQLOutputType;",
+            "line": 183,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getTypes",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Ljava/util/List;",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "forEachFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Ljava/util/function/Consumer;)V",
+            "line": 194,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinitions",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Ljava/util/List;",
+            "line": 207,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOneFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 218,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "resolveIntrospectionField",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Ljava/util/Set;Ljava/lang/String;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 229,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addObjectTypeNames",
+            "desc": "(Ljava/util/Collection;)V",
+            "line": 243,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "setObjectTypeNames",
+            "desc": "(Ljava/util/Collection;)V",
+            "line": 248,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addChild",
+            "desc": "(Lgraphql/normalized/nf/NormalizedField;)V",
+            "line": 254,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clearChildren",
+            "desc": "()V",
+            "line": 259,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 273,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 282,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getResultKey",
+            "desc": "()Ljava/lang/String;",
+            "line": 293,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAlias",
+            "desc": "()Ljava/lang/String;",
+            "line": 305,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAstArguments",
+            "desc": "()Lcom/google/common/collect/ImmutableList;",
+            "line": 312,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAstDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 316,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setAstDirectives",
+            "desc": "(Ljava/util/List;)V",
+            "line": 320,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNormalizedArgument",
+            "desc": "(Ljava/lang/String;)Lgraphql/normalized/NormalizedInputValue;",
+            "line": 331,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getNormalizedArguments",
+            "desc": "()Lcom/google/common/collect/ImmutableMap;",
+            "line": 338,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getResolvedArguments",
+            "desc": "()Ljava/util/LinkedHashMap;",
+            "line": 345,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getObjectTypeNames",
+            "desc": "()Ljava/util/Set;",
+            "line": 362,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSingleObjectTypeName",
+            "desc": "()Ljava/lang/String;",
+            "line": 373,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printDetails",
+            "desc": "()Ljava/lang/String;",
+            "line": 380,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "objectTypeNamesToString",
+            "desc": "()Ljava/lang/String;",
+            "line": 391,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getListOfResultKeys",
+            "desc": "()Ljava/util/List;",
+            "line": 405,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 6
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 418,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildrenWithSameResultKey",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 428,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "(I)Ljava/util/List;",
+            "line": 432,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 448,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getLevel",
+            "desc": "()I",
+            "line": 460,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParent",
+            "desc": "()Lgraphql/normalized/nf/NormalizedField;",
+            "line": 467,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "replaceParent",
+            "desc": "(Lgraphql/normalized/nf/NormalizedField;)V",
+            "line": 473,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 479,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "traverseSubTree",
+            "desc": "(Ljava/util/function/Consumer;)V",
+            "line": 494,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "traverseImpl",
+            "desc": "(Lgraphql/normalized/nf/NormalizedField;Ljava/util/function/Consumer;II)V",
+            "line": 503,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 5
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getInterfacesCommonToAllOutputTypes",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Ljava/util/Set;",
+            "line": 521,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newNormalizedField",
+            "desc": "()Lgraphql/normalized/nf/NormalizedField$Builder;",
+            "line": 571,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/normalized/nf/NormalizedField;",
+            "line": 581,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$getInterfacesCommonToAllOutputTypes$0",
+            "desc": "(Lgraphql/util/MutableRef;Lgraphql/schema/GraphQLFieldDefinition;)V",
+            "line": 538,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 15
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 8
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$traverseImpl$0",
+            "desc": "(Ljava/util/function/Consumer;IILgraphql/normalized/nf/NormalizedField;)V",
+            "line": 508,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$traverseSubTree$0",
+            "desc": "(Ljava/util/function/Consumer;Lgraphql/normalized/nf/NormalizedField;)V",
+            "line": 495,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$getChildren$1",
+            "desc": "(Ljava/lang/String;Lgraphql/normalized/nf/NormalizedField;)Z",
+            "line": 449,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$getChildren$0",
+            "desc": "(Ljava/util/List;ILgraphql/normalized/nf/NormalizedField;)V",
+            "line": 436,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$getChildrenWithSameResultKey$0",
+            "desc": "(Ljava/lang/String;Lgraphql/normalized/nf/NormalizedField;)Z",
+            "line": 428,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getTypes$0",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;)Lgraphql/schema/GraphQLOutputType;",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$getType$0",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;)Ljava/lang/String;",
+            "line": 184,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.nf.NormalizedDocumentFactory$NormalizedDocumentFactoryImpl": {
+        "line": {
+          "covered": 201,
+          "missed": 15
+        },
+        "branch": {
+          "covered": 78,
+          "missed": 12
+        },
+        "method": {
+          "covered": 24,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/Document;Lgraphql/normalized/nf/NormalizedDocumentFactory$Options;)V",
+            "line": 243,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createNormalizedQueryImpl",
+            "desc": "()Lgraphql/normalized/nf/NormalizedDocument;",
+            "line": 274,
+            "counters": {
+              "line": {
+                "covered": 18,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createNormalizedOperation",
+            "desc": "(Lgraphql/language/OperationDefinition;)Lgraphql/normalized/nf/NormalizedOperation;",
+            "line": 303,
+            "counters": {
+              "line": {
+                "covered": 21,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "captureMergedField",
+            "desc": "(Lgraphql/normalized/nf/NormalizedField;Lgraphql/execution/MergedField;)V",
+            "line": 338,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildNormalizedFieldsRecursively",
+            "desc": "(Lgraphql/normalized/nf/NormalizedField;Lgraphql/language/OperationDefinition;Lcom/google/common/collect/ImmutableList;I)V",
+            "line": 345,
+            "counters": {
+              "line": {
+                "covered": 38,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 13,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkMaxDepthExceeded",
+            "desc": "(I)V",
+            "line": 415,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newMergedField",
+            "desc": "(Lcom/google/common/collect/ImmutableList;)Lgraphql/execution/MergedField;",
+            "line": 421,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "updateFieldToNFMap",
+            "desc": "(Lgraphql/normalized/nf/NormalizedField;Lcom/google/common/collect/ImmutableList;)V",
+            "line": 426,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "updateCoordinatedToNFMap",
+            "desc": "(Lgraphql/normalized/nf/NormalizedField;)V",
+            "line": 432,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldsByResultKey",
+            "desc": "(Ljava/util/List;)Ljava/util/Map;",
+            "line": 440,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createNFs",
+            "desc": "(Lcom/google/common/collect/ImmutableList$Builder;Ljava/util/Map;Lcom/google/common/collect/ImmutableListMultimap$Builder;ILgraphql/normalized/nf/NormalizedField;)V",
+            "line": 453,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 9,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createNF",
+            "desc": "(Lgraphql/normalized/nf/NormalizedDocumentFactory$NormalizedDocumentFactoryImpl$CollectedFieldGroup;ILgraphql/normalized/nf/NormalizedField;)Lgraphql/normalized/nf/NormalizedField;",
+            "line": 478,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "groupByCommonParents",
+            "desc": "(Ljava/util/Collection;)Ljava/util/List;",
+            "line": 501,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "collectFromSelectionSet",
+            "desc": "(Lgraphql/language/SelectionSet;Ljava/util/List;Lgraphql/schema/GraphQLCompositeType;Ljava/util/Set;)V",
+            "line": 524,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "collectFragmentSpread",
+            "desc": "(Ljava/util/List;Lgraphql/language/FragmentSpread;Ljava/util/Set;)V",
+            "line": 545,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 5
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "collectInlineFragment",
+            "desc": "(Ljava/util/List;Lgraphql/language/InlineFragment;Ljava/util/Set;Lgraphql/schema/GraphQLCompositeType;)V",
+            "line": 566,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "collectField",
+            "desc": "(Ljava/util/List;Lgraphql/language/Field;Ljava/util/Set;Lgraphql/schema/GraphQLCompositeType;)V",
+            "line": 585,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 14,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "narrowDownPossibleObjects",
+            "desc": "(Ljava/util/Set;Lgraphql/schema/GraphQLCompositeType;)Ljava/util/Set;",
+            "line": 615,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "resolvePossibleObjects",
+            "desc": "(Ljava/util/List;)Lcom/google/common/collect/ImmutableSet;",
+            "line": 625,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "resolvePossibleObjects",
+            "desc": "(Lgraphql/schema/GraphQLCompositeType;)Lcom/google/common/collect/ImmutableSet;",
+            "line": 638,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$groupByCommonParents$1",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/normalized/nf/NormalizedDocumentFactory$NormalizedDocumentFactoryImpl$CollectedField;)Z",
+            "line": 512,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$groupByCommonParents$0",
+            "desc": "(Lgraphql/normalized/nf/NormalizedDocumentFactory$NormalizedDocumentFactoryImpl$CollectedField;)Lgraphql/schema/GraphQLType;",
+            "line": 506,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$createNF$0",
+            "desc": "(Lgraphql/normalized/nf/NormalizedDocumentFactory$NormalizedDocumentFactoryImpl$CollectedField;)Ljava/util/stream/Stream;",
+            "line": 485,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$fieldsByResultKey$0",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 442,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$newMergedField$0",
+            "desc": "(Lgraphql/normalized/nf/NormalizedDocumentFactory$NormalizedDocumentFactoryImpl$CollectedField;)Lgraphql/language/Field;",
+            "line": 421,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.nf.NormalizedDocumentFactory$NormalizedDocumentFactoryImpl$CollectedField": {
+        "line": {
+          "covered": 5,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Field;Ljava/util/Set;Lgraphql/schema/GraphQLCompositeType;)V",
+            "line": 665,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.nf.NormalizedDocumentFactory$NormalizedDocumentFactoryImpl$CollectedFieldGroup": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Set;Ljava/util/Set;)V",
+            "line": 676,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.nf.NormalizedOperation": {
+        "line": {
+          "covered": 14,
+          "missed": 17
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 6
+        },
+        "method": {
+          "covered": 4,
+          "missed": 10
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/OperationDefinition$Operation;Ljava/lang/String;Ljava/util/List;Lcom/google/common/collect/ImmutableListMultimap;Ljava/util/Map;Ljava/util/Map;Lcom/google/common/collect/ImmutableListMultimap;II)V",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOperation",
+            "desc": "()Lgraphql/language/OperationDefinition$Operation;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOperationName",
+            "desc": "()Ljava/lang/String;",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOperationFieldCount",
+            "desc": "()I",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getOperationDepth",
+            "desc": "()I",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getCoordinatesToNormalizedFields",
+            "desc": "()Lcom/google/common/collect/ImmutableListMultimap;",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getRootFields",
+            "desc": "()Ljava/util/List;",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldToNormalizedField",
+            "desc": "()Lcom/google/common/collect/ImmutableListMultimap;",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getNormalizedFields",
+            "desc": "(Lgraphql/language/Field;)Ljava/util/List;",
+            "line": 119,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getNormalizedFieldToMergedField",
+            "desc": "()Ljava/util/Map;",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getMergedField",
+            "desc": "(Lgraphql/normalized/nf/NormalizedField;)Lgraphql/execution/MergedField;",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getNormalizedFieldToQueryDirectives",
+            "desc": "()Ljava/util/Map;",
+            "line": 144,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getQueryDirectives",
+            "desc": "(Lgraphql/normalized/nf/NormalizedField;)Lgraphql/execution/directives/QueryDirectives;",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getNormalizedField",
+            "desc": "(Lgraphql/execution/MergedField;Lgraphql/schema/GraphQLFieldsContainer;Lgraphql/execution/ResultPath;)Lgraphql/normalized/nf/NormalizedField;",
+            "line": 169,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 8
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 6
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.nf.NormalizedOperationToAstCompiler$CompilerResult": {
+        "line": {
+          "covered": 5,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Document;Ljava/util/Map;)V",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDocument",
+            "desc": "()Lgraphql/language/Document;",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getVariables",
+            "desc": "()Ljava/util/Map;",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.nf.NormalizedDocument": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 1,
+          "missed": 1
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;)V",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNormalizedOperations",
+            "desc": "()Ljava/util/List;",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSingleNormalizedOperation",
+            "desc": "()Lgraphql/normalized/nf/NormalizedOperation;",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.nf.NormalizedDocumentFactory$NormalizedDocumentFactoryImpl$PossibleMerger": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/normalized/nf/NormalizedField;Ljava/lang/String;)V",
+            "line": 654,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.nf.NormalizedDocumentFactory": {
+        "line": {
+          "covered": 5,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "createNormalizedDocument",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/Document;)Lgraphql/normalized/nf/NormalizedDocument;",
+            "line": 219,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createNormalizedDocument",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/Document;Lgraphql/normalized/nf/NormalizedDocumentFactory$Options;)Lgraphql/normalized/nf/NormalizedDocument;",
+            "line": 229,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 210,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.nf.NormalizedDocument$NormalizedOperationWithAssumedSkipIncludeVariables": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Map;Lgraphql/normalized/nf/NormalizedOperation;)V",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAssumedSkipIncludeVariables",
+            "desc": "()Ljava/util/Map;",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNormalizedOperation",
+            "desc": "()Lgraphql/normalized/nf/NormalizedOperation;",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.nf.NormalizedFieldsMerger": {
+        "line": {
+          "covered": 72,
+          "missed": 38
+        },
+        "branch": {
+          "covered": 38,
+          "missed": 36
+        },
+        "method": {
+          "covered": 9,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 21,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "merge",
+            "desc": "(Lgraphql/normalized/nf/NormalizedField;Ljava/util/List;Lgraphql/schema/GraphQLSchema;)V",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 39,
+                "missed": 5
+              },
+              "branch": {
+                "covered": 19,
+                "missed": 5
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isFieldInSharedInterface",
+            "desc": "(Lgraphql/normalized/nf/NormalizedField;Lgraphql/normalized/nf/NormalizedField;Lgraphql/schema/GraphQLSchema;)Z",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "areFieldSetsTheSame",
+            "desc": "(Ljava/util/List;)Z",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "compareTwoFieldSets",
+            "desc": "(Ljava/util/Set;Ljava/util/Set;)Z",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isContained",
+            "desc": "(Lgraphql/normalized/nf/NormalizedField;Ljava/util/Set;)Z",
+            "line": 144,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 5
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 4
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "compareWithoutChildren",
+            "desc": "(Lgraphql/normalized/nf/NormalizedField;Lgraphql/normalized/nf/NormalizedField;)Z",
+            "line": 154,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 9
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 8
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "sameArguments",
+            "desc": "(Ljava/util/List;Ljava/util/List;)Z",
+            "line": 171,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 7
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 6
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "findArgumentByName",
+            "desc": "(Ljava/lang/String;Ljava/util/List;)Lgraphql/language/Argument;",
+            "line": 187,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 5
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 4
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$isFieldInSharedInterface$1",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLInterfaceType;)Z",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isFieldInSharedInterface$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLInterfaceType;)Z",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$merge$1",
+            "desc": "(Ljava/util/List;Lgraphql/normalized/nf/NormalizedField;)V",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$merge$0",
+            "desc": "(Ljava/util/Set;Lgraphql/normalized/nf/NormalizedField;)V",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.visitor.GraphQLSchemaVisitorAdapter$DirectiveEnv": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/util/TraverserContext;)V",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.visitor.GraphQLSchemaVisitorAdapter$EnumTypeEnv": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/util/TraverserContext;)V",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.visitor.GraphQLSchemaVisitorAdapter$InputObjectFieldEnv": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/util/TraverserContext;)V",
+            "line": 189,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getContainer",
+            "desc": "()Lgraphql/schema/GraphQLInputObjectType;",
+            "line": 194,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getUnwrappedType",
+            "desc": "()Lgraphql/schema/GraphQLNamedInputType;",
+            "line": 199,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.visitor.GraphQLSchemaVisitorAdapter$InterfaceTypeEnv": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/util/TraverserContext;)V",
+            "line": 222,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.visitor.GraphQLSchemaVisitorAdapter$AppliedDirectiveArgumentEnv": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/util/TraverserContext;)V",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getContainer",
+            "desc": "()Lgraphql/schema/GraphQLAppliedDirective;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getUnwrappedType",
+            "desc": "()Lgraphql/schema/GraphQLNamedInputType;",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.visitor.GraphQLSchemaVisitorEnvironmentImpl": {
+        "line": {
+          "covered": 19,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 5,
+          "missed": 3
+        },
+        "method": {
+          "covered": 9,
+          "missed": 6
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/util/TraverserContext;)V",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSchema",
+            "desc": "()Lgraphql/schema/GraphQLSchema;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCodeRegistry",
+            "desc": "()Lgraphql/schema/GraphQLCodeRegistry$Builder;",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getElement",
+            "desc": "()Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLeadingElements",
+            "desc": "()Ljava/util/List;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getUnwrappedLeadingElements",
+            "desc": "()Ljava/util/List;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "buildParentsImpl",
+            "desc": "(Ljava/util/function/Predicate;)Ljava/util/List;",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ok",
+            "desc": "()Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "quit",
+            "desc": "()Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "changeNode",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deleteNode",
+            "desc": "()Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "insertAfter",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "insertBefore",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$getUnwrappedLeadingElements$0",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;)Z",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$getLeadingElements$0",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;)Z",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.visitor.GraphQLSchemaVisitorAdapter$InputObjectTypeEnv": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/util/TraverserContext;)V",
+            "line": 210,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.visitor.GraphQLSchemaVisitorAdapter$ArgumentEnv": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/util/TraverserContext;)V",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getContainer",
+            "desc": "()Lgraphql/schema/GraphQLNamedSchemaElement;",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getUnwrappedType",
+            "desc": "()Lgraphql/schema/GraphQLNamedInputType;",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.visitor.GraphQLSchemaTraversalControl": {
+        "line": {
+          "covered": 17,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 15,
+          "missed": 7
+        },
+        "method": {
+          "covered": 5,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/visitor/GraphQLSchemaTraversalControl$Control;Lgraphql/schema/GraphQLSchemaElement;)V",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getElement",
+            "desc": "()Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getControl",
+            "desc": "()Lgraphql/schema/visitor/GraphQLSchemaTraversalControl$Control;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isAbortive",
+            "desc": "()Z",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isMutative",
+            "desc": "()Z",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toTraversalControl",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 4
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.visitor.GraphQLSchemaVisitorAdapter$UnionTypeEnv": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/util/TraverserContext;)V",
+            "line": 257,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.visitor.GraphQLSchemaVisitorAdapter$AppliedDirectiveEnv": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/util/TraverserContext;)V",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getContainer",
+            "desc": "()Lgraphql/schema/GraphQLDirectiveContainer;",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.visitor.GraphQLSchemaVisitorAdapter$EnumValueDefinitionEnv": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/util/TraverserContext;)V",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getContainer",
+            "desc": "()Lgraphql/schema/GraphQLEnumType;",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.visitor.GraphQLSchemaVisitor": {
+        "line": {
+          "covered": 14,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 14,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "visitAppliedDirective",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirective;Lgraphql/schema/visitor/GraphQLSchemaVisitor$AppliedDirectiveVisitorEnvironment;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitAppliedDirectiveArgument",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirectiveArgument;Lgraphql/schema/visitor/GraphQLSchemaVisitor$AppliedDirectiveArgumentVisitorEnvironment;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitArgument",
+            "desc": "(Lgraphql/schema/GraphQLArgument;Lgraphql/schema/visitor/GraphQLSchemaVisitor$ArgumentVisitorEnvironment;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;Lgraphql/schema/visitor/GraphQLSchemaVisitor$DirectiveVisitorEnvironment;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "visitEnumType",
+            "desc": "(Lgraphql/schema/GraphQLEnumType;Lgraphql/schema/visitor/GraphQLSchemaVisitor$EnumTypeVisitorEnvironment;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 134,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitEnumValueDefinition",
+            "desc": "(Lgraphql/schema/GraphQLEnumValueDefinition;Lgraphql/schema/visitor/GraphQLSchemaVisitor$EnumValueDefinitionVisitorEnvironment;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/visitor/GraphQLSchemaVisitor$FieldDefinitionVisitorEnvironment;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 178,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitInputObjectField",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;Lgraphql/schema/visitor/GraphQLSchemaVisitor$InputObjectFieldVisitorEnvironment;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 202,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitInputObjectType",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;Lgraphql/schema/visitor/GraphQLSchemaVisitor$InputObjectTypeVisitorEnvironment;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 220,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitInterfaceType",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;Lgraphql/schema/visitor/GraphQLSchemaVisitor$InterfaceTypeVisitorEnvironment;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 238,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitObjectType",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/schema/visitor/GraphQLSchemaVisitor$ObjectVisitorEnvironment;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 257,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitScalarType",
+            "desc": "(Lgraphql/schema/GraphQLScalarType;Lgraphql/schema/visitor/GraphQLSchemaVisitor$ScalarTypeVisitorEnvironment;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 275,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitUnionType",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;Lgraphql/schema/visitor/GraphQLSchemaVisitor$UnionTypeVisitorEnvironment;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 293,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitSchemaElement",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;Lgraphql/schema/visitor/GraphQLSchemaVisitor$SchemaElementVisitorEnvironment;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 313,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toTypeVisitor",
+            "desc": "()Lgraphql/schema/GraphQLTypeVisitor;",
+            "line": 322,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.visitor.GraphQLSchemaVisitorAdapter$FieldDefinitionEnv": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/util/TraverserContext;)V",
+            "line": 168,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getContainer",
+            "desc": "()Lgraphql/schema/GraphQLFieldsContainer;",
+            "line": 173,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getUnwrappedType",
+            "desc": "()Lgraphql/schema/GraphQLNamedOutputType;",
+            "line": 178,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.visitor.GraphQLSchemaTraversalControl$Control": {
+        "line": {
+          "covered": 11,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;ILgraphql/util/TraversalControl;)V",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toTraversalControl",
+            "desc": "()Lgraphql/util/TraversalControl;",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.visitor.GraphQLSchemaVisitorAdapter": {
+        "line": {
+          "covered": 23,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 6,
+          "missed": 0
+        },
+        "method": {
+          "covered": 28,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/visitor/GraphQLSchemaVisitor;)V",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitE",
+            "desc": "(Lgraphql/util/TraverserContext;Ljava/util/function/Supplier;)Lgraphql/util/TraversalControl;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLAppliedDirectiveArgument",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirectiveArgument;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLAppliedDirective",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirective;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLArgument",
+            "desc": "(Lgraphql/schema/GraphQLArgument;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLEnumType",
+            "desc": "(Lgraphql/schema/GraphQLEnumType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLEnumValueDefinition",
+            "desc": "(Lgraphql/schema/GraphQLEnumValueDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 184,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputObjectField",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 205,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputObjectType",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 216,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInterfaceType",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 228,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLObjectType",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 240,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLScalarType",
+            "desc": "(Lgraphql/schema/GraphQLScalarType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 252,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLUnionType",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 263,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLUnionType$0",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;Lgraphql/util/TraverserContext;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 263,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLScalarType$0",
+            "desc": "(Lgraphql/schema/GraphQLScalarType;Lgraphql/util/TraverserContext;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 252,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLObjectType$0",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/util/TraverserContext;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 240,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLInterfaceType$0",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;Lgraphql/util/TraverserContext;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 228,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLInputObjectType$0",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;Lgraphql/util/TraverserContext;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 216,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLInputObjectField$0",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;Lgraphql/util/TraverserContext;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 205,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLFieldDefinition$0",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/util/TraverserContext;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 184,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLEnumValueDefinition$0",
+            "desc": "(Lgraphql/schema/GraphQLEnumValueDefinition;Lgraphql/util/TraverserContext;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLEnumType$0",
+            "desc": "(Lgraphql/schema/GraphQLEnumType;Lgraphql/util/TraverserContext;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLDirective$0",
+            "desc": "(Lgraphql/schema/GraphQLDirective;Lgraphql/util/TraverserContext;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLArgument$0",
+            "desc": "(Lgraphql/schema/GraphQLArgument;Lgraphql/util/TraverserContext;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLAppliedDirective$0",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirective;Lgraphql/util/TraverserContext;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLAppliedDirectiveArgument$0",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirectiveArgument;Lgraphql/util/TraverserContext;)Lgraphql/schema/visitor/GraphQLSchemaTraversalControl;",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.visitor.GraphQLSchemaVisitorAdapter$SchemaElementEnv": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/util/TraverserContext;)V",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.visitor.GraphQLSchemaVisitorAdapter$ObjectEnv": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/util/TraverserContext;)V",
+            "line": 233,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.visitor.GraphQLSchemaVisitorAdapter$ScalarTypeEnv": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/util/TraverserContext;)V",
+            "line": 246,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.collect.ImmutableKit": {
+        "line": {
+          "covered": 73,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 26,
+          "missed": 0
+        },
+        "method": {
+          "covered": 14,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "emptyList",
+            "desc": "()Lcom/google/common/collect/ImmutableList;",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "nonNullCopyOf",
+            "desc": "(Ljava/util/Collection;)Lcom/google/common/collect/ImmutableList;",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "emptyMap",
+            "desc": "()Lcom/google/common/collect/ImmutableMap;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addToMap",
+            "desc": "(Ljava/util/Map;Ljava/lang/Object;Ljava/lang/Object;)Lcom/google/common/collect/ImmutableMap;",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "concatLists",
+            "desc": "(Ljava/util/List;Ljava/util/List;)Lcom/google/common/collect/ImmutableList;",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "map",
+            "desc": "(Ljava/util/Collection;Ljava/util/function/Function;)Lcom/google/common/collect/ImmutableList;",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mapToSet",
+            "desc": "(Ljava/util/Collection;Ljava/util/function/Function;)Lcom/google/common/collect/ImmutableSet;",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "(Ljava/util/Collection;Ljava/util/function/Predicate;)Lcom/google/common/collect/ImmutableList;",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filterAndMap",
+            "desc": "(Ljava/util/Collection;Ljava/util/function/Predicate;Ljava/util/function/Function;)Lcom/google/common/collect/ImmutableList;",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "flatMapList",
+            "desc": "(Ljava/util/Collection;)Lcom/google/common/collect/ImmutableList;",
+            "line": 119,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mapAndDropNulls",
+            "desc": "(Ljava/util/Collection;Ljava/util/function/Function;)Lcom/google/common/collect/ImmutableList;",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addToList",
+            "desc": "(Ljava/util/Collection;Ljava/lang/Object;[Ljava/lang/Object;)Lcom/google/common/collect/ImmutableList;",
+            "line": 164,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addToSet",
+            "desc": "(Ljava/util/Collection;Ljava/lang/Object;[Ljava/lang/Object;)Lcom/google/common/collect/ImmutableSet;",
+            "line": 188,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filterVarArgs",
+            "desc": "(Ljava/util/function/Predicate;[Ljava/lang/Object;)Ljava/util/List;",
+            "line": 212,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.collect.ImmutableMapWithNullValues": {
+        "line": {
+          "covered": 21,
+          "missed": 17
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 13,
+          "missed": 16
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Map;)V",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "emptyMap",
+            "desc": "()Lgraphql/collect/ImmutableMapWithNullValues;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "copyOf",
+            "desc": "(Ljava/util/Map;)Lgraphql/collect/ImmutableMapWithNullValues;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "size",
+            "desc": "()I",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEmpty",
+            "desc": "()Z",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "containsKey",
+            "desc": "(Ljava/lang/Object;)Z",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "containsValue",
+            "desc": "(Ljava/lang/Object;)Z",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "get",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "put",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "remove",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "putAll",
+            "desc": "(Ljava/util/Map;)V",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "clear",
+            "desc": "()V",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "keySet",
+            "desc": "()Ljava/util/Set;",
+            "line": 109,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "values",
+            "desc": "()Ljava/util/Collection;",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "entrySet",
+            "desc": "()Ljava/util/Set;",
+            "line": 119,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOrDefault",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 134,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "forEach",
+            "desc": "(Ljava/util/function/BiConsumer;)V",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "replaceAll",
+            "desc": "(Ljava/util/function/BiFunction;)V",
+            "line": 145,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "putIfAbsent",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "remove",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;)Z",
+            "line": 157,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "replace",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Z",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "replace",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 169,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "computeIfAbsent",
+            "desc": "(Ljava/lang/Object;Ljava/util/function/Function;)Ljava/lang/Object;",
+            "line": 175,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "computeIfPresent",
+            "desc": "(Ljava/lang/Object;Ljava/util/function/BiFunction;)Ljava/lang/Object;",
+            "line": 181,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "compute",
+            "desc": "(Ljava/lang/Object;Ljava/util/function/BiFunction;)Ljava/lang/Object;",
+            "line": 187,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "merge",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;Ljava/util/function/BiFunction;)Ljava/lang/Object;",
+            "line": 193,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 198,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.fetching.LambdaFetchingSupport": {
+        "line": {
+          "covered": 82,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 68,
+          "missed": 8
+        },
+        "method": {
+          "covered": 19,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "createGetter",
+            "desc": "(Ljava/lang/Class;Ljava/lang/String;)Ljava/util/Optional;",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCandidateMethod",
+            "desc": "(Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/reflect/Method;",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkForSingleParameterPeer",
+            "desc": "(Ljava/lang/reflect/Method;Ljava/util/List;)Ljava/lang/reflect/Method;",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "findBestBooleanGetter",
+            "desc": "(Ljava/util/List;)Ljava/lang/reflect/Method;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "findMethodsForProperty",
+            "desc": "(Ljava/lang/Class;Ljava/util/function/Predicate;)Ljava/util/List;",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isPossiblePojoMethod",
+            "desc": "(Ljava/lang/reflect/Method;)Z",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isRecordLike",
+            "desc": "(Ljava/lang/reflect/Method;)Z",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isBooleanGetter",
+            "desc": "(Ljava/lang/reflect/Method;)Z",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasNoParameters",
+            "desc": "(Ljava/lang/reflect/Method;)Z",
+            "line": 158,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isGetterNamed",
+            "desc": "(Ljava/lang/reflect/Method;)Z",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "returnsSomething",
+            "desc": "(Ljava/lang/reflect/Method;)Z",
+            "line": 167,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isPublic",
+            "desc": "(Ljava/lang/reflect/Method;)Z",
+            "line": 171,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isObjectMethod",
+            "desc": "(Ljava/lang/reflect/Method;)Z",
+            "line": 175,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkPropertyNameGetter",
+            "desc": "(Ljava/lang/reflect/Method;)Ljava/lang/String;",
+            "line": 183,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "decapitalize",
+            "desc": "(Ljava/lang/String;)Ljava/lang/String;",
+            "line": 193,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkCallFunction",
+            "desc": "(Ljava/lang/Class;Ljava/lang/String;Ljava/lang/Class;)Ljava/util/function/Function;",
+            "line": 202,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLookup",
+            "desc": "(Ljava/lang/Class;)Ljava/lang/invoke/MethodHandles$Lookup;",
+            "line": 216,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getCandidateMethod$1",
+            "desc": "(Ljava/lang/String;Ljava/lang/reflect/Method;)Z",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getCandidateMethod$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/reflect/Method;)Z",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.conditional.ConditionalNodeDecisionEnvironment": {
+        "line": {
+          "covered": 1,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.conditional.ConditionalNodes$1": {
+        "line": {
+          "covered": 5,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/conditional/ConditionalNodes;Lgraphql/language/DirectivesContainer;Lgraphql/execution/CoercedVariables;Lgraphql/schema/GraphQLSchema;Lgraphql/GraphQLContext;)V",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesContainer",
+            "desc": "()Lgraphql/language/DirectivesContainer;",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getVariables",
+            "desc": "()Lgraphql/execution/CoercedVariables;",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getGraphQlSchema",
+            "desc": "()Lgraphql/schema/GraphQLSchema;",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getGraphQLContext",
+            "desc": "()Lgraphql/GraphQLContext;",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.conditional.ConditionalNodes": {
+        "line": {
+          "covered": 43,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 27,
+          "missed": 9
+        },
+        "method": {
+          "covered": 9,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "shouldIncludeWithoutVariables",
+            "desc": "(Lgraphql/language/DirectivesContainer;)Ljava/lang/Boolean;",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "shouldInclude",
+            "desc": "(Lgraphql/language/DirectivesContainer;Ljava/util/Map;Lgraphql/schema/GraphQLSchema;Lgraphql/GraphQLContext;)Z",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "customShouldInclude",
+            "desc": "(Ljava/util/Map;Lgraphql/language/DirectivesContainer;Lgraphql/schema/GraphQLSchema;Lgraphql/GraphQLContext;Lgraphql/execution/conditional/ConditionalNodeDecision;)Z",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "shouldInclude",
+            "desc": "(Ljava/util/Map;Ljava/util/List;)Ljava/lang/Boolean;",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "containsSkipOrIncludeDirective",
+            "desc": "(Lgraphql/language/DirectivesContainer;)Z",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 4
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getSkipVariableName",
+            "desc": "(Lgraphql/language/DirectivesContainer;)Ljava/lang/String;",
+            "line": 109,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getIncludeVariableName",
+            "desc": "(Lgraphql/language/DirectivesContainer;)Ljava/lang/String;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectiveResult",
+            "desc": "(Ljava/util/Map;Ljava/util/List;Ljava/lang/String;Z)Ljava/lang/Boolean;",
+            "line": 134,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getIfValue",
+            "desc": "(Ljava/util/List;Ljava/util/Map;)Ljava/lang/Boolean;",
+            "line": 142,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.reactive.NonBlockingMutexExecutor": {
+        "line": {
+          "covered": 17,
+          "missed": 10
+        },
+        "branch": {
+          "covered": 5,
+          "missed": 7
+        },
+        "method": {
+          "covered": 4,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "execute",
+            "desc": "(Ljava/lang/Runnable;)V",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "reportFailure",
+            "desc": "(Ljava/lang/Thread;Ljava/lang/Throwable;)V",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 6
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 4
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "run",
+            "desc": "(Lgraphql/execution/reactive/NonBlockingMutexExecutor$RunNode;)V",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "runAll",
+            "desc": "(Lgraphql/execution/reactive/NonBlockingMutexExecutor$RunNode;)V",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.reactive.ReactiveSupport$AtTheEndPublisher$1": {
+        "line": {
+          "covered": 11,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/reactive/ReactiveSupport$AtTheEndPublisher;Lorg/reactivestreams/Subscriber;)V",
+            "line": 173,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onSubscribe",
+            "desc": "(Lorg/reactivestreams/Subscription;)V",
+            "line": 176,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onNext",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 181,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onError",
+            "desc": "(Ljava/lang/Throwable;)V",
+            "line": 186,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onComplete",
+            "desc": "()V",
+            "line": 192,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.reactive.CompletionStageMappingPublisher": {
+        "line": {
+          "covered": 8,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lorg/reactivestreams/Publisher;Ljava/util/function/Function;)V",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "subscribe",
+            "desc": "(Lorg/reactivestreams/Subscriber;)V",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createSubscriber",
+            "desc": "(Lorg/reactivestreams/Subscriber;)Lorg/reactivestreams/Subscriber;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getUpstreamPublisher",
+            "desc": "()Lorg/reactivestreams/Publisher;",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.reactive.NonBlockingMutexExecutor$RunNode": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Runnable;)V",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.reactive.DelegatingSubscription": {
+        "line": {
+          "covered": 7,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lorg/reactivestreams/Subscription;)V",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "request",
+            "desc": "(J)V",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "cancel",
+            "desc": "()V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getUpstreamSubscription",
+            "desc": "()Lorg/reactivestreams/Subscription;",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.reactive.CompletionStageOrderedSubscriber": {
+        "line": {
+          "covered": 26,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 11,
+          "missed": 1
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/function/Function;Lorg/reactivestreams/Subscriber;)V",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "whenNextFinished",
+            "desc": "(Ljava/util/concurrent/CompletionStage;Ljava/lang/Object;Ljava/lang/Throwable;)V",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "emptyInFlightQueueIfWeCan",
+            "desc": "()V",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "cfExceptionUnwrap",
+            "desc": "(Ljava/lang/Throwable;)Ljava/lang/Throwable;",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$emptyInFlightQueueIfWeCan$0",
+            "desc": "()V",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.reactive.ReactiveSupport": {
+        "line": {
+          "covered": 9,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "fetchedObject",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "flowPublisherToCF",
+            "desc": "(Ljava/util/concurrent/Flow$Publisher;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "whenPublisherFinishes",
+            "desc": "(Lorg/reactivestreams/Publisher;Ljava/util/function/Consumer;)Lorg/reactivestreams/Publisher;",
+            "line": 158,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.reactive.CompletionStageSubscriber": {
+        "line": {
+          "covered": 73,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 19,
+          "missed": 5
+        },
+        "method": {
+          "covered": 21,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/function/Function;Lorg/reactivestreams/Subscriber;)V",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDownstreamSubscriber",
+            "desc": "()Lorg/reactivestreams/Subscriber;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "onSubscribe",
+            "desc": "(Lorg/reactivestreams/Subscription;)V",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onNext",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "whenComplete",
+            "desc": "(Ljava/util/concurrent/CompletionStage;)Ljava/util/function/BiConsumer;",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "whenNextFinished",
+            "desc": "(Ljava/util/concurrent/CompletionStage;Ljava/lang/Object;Ljava/lang/Throwable;)V",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "finallyAfterEachPromiseFinishes",
+            "desc": "()V",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleThrowableDuringMapping",
+            "desc": "(Ljava/lang/Throwable;)V",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onError",
+            "desc": "(Ljava/lang/Throwable;)V",
+            "line": 135,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onComplete",
+            "desc": "()V",
+            "line": 143,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onComplete",
+            "desc": "(Ljava/lang/Runnable;)V",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "offerToInFlightQ",
+            "desc": "(Ljava/util/concurrent/CompletionStage;)V",
+            "line": 164,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "removeFromInFlightQ",
+            "desc": "(Ljava/util/concurrent/CompletionStage;)V",
+            "line": 170,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "cancelInFlightFutures",
+            "desc": "()V",
+            "line": 178,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isTerminal",
+            "desc": "()Z",
+            "line": 194,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$cancelInFlightFutures$0",
+            "desc": "()V",
+            "line": 179,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$removeFromInFlightQ$0",
+            "desc": "(Ljava/util/concurrent/CompletionStage;)V",
+            "line": 170,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$offerToInFlightQ$0",
+            "desc": "(Ljava/util/concurrent/CompletionStage;)V",
+            "line": 165,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$onComplete$1",
+            "desc": "(Ljava/lang/Runnable;)Ljava/lang/Boolean;",
+            "line": 152,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$onComplete$0",
+            "desc": "()V",
+            "line": 144,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$finallyAfterEachPromiseFinishes$0",
+            "desc": "()Ljava/lang/Runnable;",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$whenComplete$0",
+            "desc": "(Ljava/util/concurrent/CompletionStage;Ljava/lang/Object;Ljava/lang/Throwable;)V",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.reactive.SubscriptionPublisher": {
+        "line": {
+          "covered": 8,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lorg/reactivestreams/Publisher;Ljava/util/function/Function;ZLjava/util/function/Consumer;)V",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getUpstreamPublisher",
+            "desc": "()Lorg/reactivestreams/Publisher;",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "subscribe",
+            "desc": "(Lorg/reactivestreams/Subscriber;)V",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.reactive.CompletionStageMappingOrderedPublisher": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lorg/reactivestreams/Publisher;Ljava/util/function/Function;)V",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createSubscriber",
+            "desc": "(Lorg/reactivestreams/Subscriber;)Lorg/reactivestreams/Subscriber;",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.reactive.SingleSubscriberPublisher$1": {
+        "line": {
+          "covered": 2,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/reactive/SingleSubscriberPublisher;)V",
+            "line": 118,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "request",
+            "desc": "(J)V",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "cancel",
+            "desc": "()V",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.reactive.SingleSubscriberPublisher$SimpleSubscription": {
+        "line": {
+          "covered": 17,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 6,
+          "missed": 6
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/reactive/SingleSubscriberPublisher;)V",
+            "line": 152,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "request",
+            "desc": "(J)V",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "cancel",
+            "desc": "()V",
+            "line": 175,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$cancel$0",
+            "desc": "()V",
+            "line": 176,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$request$0",
+            "desc": "(J)V",
+            "line": 157,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 5
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.reactive.ReactiveSupport$PublisherToCompletableFuture": {
+        "line": {
+          "covered": 25,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 8,
+          "missed": 6
+        },
+        "method": {
+          "covered": 7,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateSubscription",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;)Z",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "cancel",
+            "desc": "(Z)Z",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onSubscribeImpl",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onNextImpl",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onErrorImpl",
+            "desc": "(Ljava/lang/Throwable;)V",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onCompleteImpl",
+            "desc": "()V",
+            "line": 109,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.reactive.SingleSubscriberPublisher": {
+        "line": {
+          "covered": 63,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 18,
+          "missed": 4
+        },
+        "method": {
+          "covered": 14,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/reactive/SingleSubscriberPublisher$OnSubscriptionCallback;)V",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "offer",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 63,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "noMoreData",
+            "desc": "()V",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "offerError",
+            "desc": "(Ljava/lang/Throwable;)V",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleError",
+            "desc": "(Ljava/lang/Throwable;)V",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleOnComplete",
+            "desc": "()V",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "subscribe",
+            "desc": "(Lorg/reactivestreams/Subscriber;)V",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "maybeReadInMutex",
+            "desc": "()V",
+            "line": 133,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 12,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$subscribe$0",
+            "desc": "(Lorg/reactivestreams/Subscriber;)V",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$offerError$0",
+            "desc": "(Ljava/lang/Throwable;)V",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$noMoreData$0",
+            "desc": "()V",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$offer$0",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$0",
+            "desc": "()V",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.reactive.ReactiveSupport$FlowPublisherToCompletableFuture": {
+        "line": {
+          "covered": 12,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "doSubscriptionCancel",
+            "desc": "(Ljava/util/concurrent/Flow$Subscription;)V",
+            "line": 119,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "doSubscriptionRequest",
+            "desc": "(Ljava/util/concurrent/Flow$Subscription;J)V",
+            "line": 124,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onSubscribe",
+            "desc": "(Ljava/util/concurrent/Flow$Subscription;)V",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onNext",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 134,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onError",
+            "desc": "(Ljava/lang/Throwable;)V",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onComplete",
+            "desc": "()V",
+            "line": 144,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.reactive.ReactiveSupport$AtTheEndPublisher": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lorg/reactivestreams/Publisher;Ljava/util/function/Consumer;)V",
+            "line": 166,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "subscribe",
+            "desc": "(Lorg/reactivestreams/Subscriber;)V",
+            "line": 173,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.preparsed.persisted.PersistedQueryError": {
+        "line": {
+          "covered": 1,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 8,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 11,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.preparsed.persisted.PersistedQueryIdInvalid": {
+        "line": {
+          "covered": 9,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 14,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMessage",
+            "desc": "()Ljava/lang/String;",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPersistedQueryId",
+            "desc": "()Ljava/lang/Object;",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.preparsed.persisted.InMemoryPersistedQueryCache$Builder": {
+        "line": {
+          "covered": 5,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addQuery",
+            "desc": "(Ljava/lang/Object;Ljava/lang/String;)Lgraphql/execution/preparsed/persisted/InMemoryPersistedQueryCache$Builder;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/execution/preparsed/persisted/InMemoryPersistedQueryCache;",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.preparsed.persisted.ApolloPersistedQuerySupport": {
+        "line": {
+          "covered": 13,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/preparsed/persisted/PersistedQueryCache;)V",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPersistedQueryId",
+            "desc": "(Lgraphql/ExecutionInput;)Ljava/util/Optional;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "persistedQueryIdIsInvalid",
+            "desc": "(Ljava/lang/Object;Ljava/lang/String;)Z",
+            "line": 63,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.preparsed.persisted.InMemoryPersistedQueryCache": {
+        "line": {
+          "covered": 15,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 7,
+          "missed": 3
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Map;)V",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getKnownQueries",
+            "desc": "()Ljava/util/Map;",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPersistedQueryDocumentAsync",
+            "desc": "(Ljava/lang/Object;Lgraphql/ExecutionInput;Lgraphql/execution/preparsed/persisted/PersistedQueryCacheMiss;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newInMemoryPersistedQueryCache",
+            "desc": "()Lgraphql/execution/preparsed/persisted/InMemoryPersistedQueryCache$Builder;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getPersistedQueryDocumentAsync$0",
+            "desc": "(Lgraphql/ExecutionInput;Ljava/lang/Object;Lgraphql/execution/preparsed/persisted/PersistedQueryCacheMiss;Ljava/lang/Object;Lgraphql/execution/preparsed/PreparsedDocumentEntry;)Lgraphql/execution/preparsed/PreparsedDocumentEntry;",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.preparsed.persisted.PersistedQuerySupport": {
+        "line": {
+          "covered": 20,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 6,
+          "missed": 2
+        },
+        "method": {
+          "covered": 5,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/preparsed/persisted/PersistedQueryCache;)V",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDocumentAsync",
+            "desc": "(Lgraphql/ExecutionInput;Ljava/util/function/Function;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "persistedQueryIdIsInvalid",
+            "desc": "(Ljava/lang/Object;Ljava/lang/String;)Z",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "mkMissingError",
+            "desc": "(Lgraphql/execution/preparsed/persisted/PersistedQueryError;)Lgraphql/execution/preparsed/PreparsedDocumentEntry;",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getDocumentAsync$0",
+            "desc": "(Ljava/lang/Object;Lgraphql/ExecutionInput;Ljava/util/function/Function;Ljava/lang/String;)Lgraphql/execution/preparsed/PreparsedDocumentEntry;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getDocumentAsync$1",
+            "desc": "(Ljava/lang/String;Lgraphql/ExecutionInput$Builder;)V",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.preparsed.persisted.PersistedQueryNotFound": {
+        "line": {
+          "covered": 9,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMessage",
+            "desc": "()Ljava/lang/String;",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPersistedQueryId",
+            "desc": "()Ljava/lang/Object;",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.impl.MultiReadOnlyGraphQLTypeVisitor": {
+        "line": {
+          "covered": 37,
+          "missed": 22
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 35,
+          "missed": 22
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;)V",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLAppliedDirective",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirective;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLAppliedDirectiveArgument",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirectiveArgument;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLArgument",
+            "desc": "(Lgraphql/schema/GraphQLArgument;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInterfaceType",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLEnumType",
+            "desc": "(Lgraphql/schema/GraphQLEnumType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLEnumValueDefinition",
+            "desc": "(Lgraphql/schema/GraphQLEnumValueDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputObjectField",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputObjectType",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 106,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLList",
+            "desc": "(Lgraphql/schema/GraphQLList;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLNonNull",
+            "desc": "(Lgraphql/schema/GraphQLNonNull;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 118,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLObjectType",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 124,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLScalarType",
+            "desc": "(Lgraphql/schema/GraphQLScalarType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLTypeReference",
+            "desc": "(Lgraphql/schema/GraphQLTypeReference;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLUnionType",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 142,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitBackRef",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 148,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLModifiedType",
+            "desc": "(Lgraphql/schema/GraphQLModifiedType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 154,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLCompositeType",
+            "desc": "(Lgraphql/schema/GraphQLCompositeType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 160,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLDirectiveContainer",
+            "desc": "(Lgraphql/schema/GraphQLDirectiveContainer;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 166,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLFieldsContainer",
+            "desc": "(Lgraphql/schema/GraphQLFieldsContainer;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 172,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputFieldsContainer",
+            "desc": "(Lgraphql/schema/GraphQLInputFieldsContainer;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 178,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputType",
+            "desc": "(Lgraphql/schema/GraphQLInputType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 184,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLNullableType",
+            "desc": "(Lgraphql/schema/GraphQLNullableType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLOutputType",
+            "desc": "(Lgraphql/schema/GraphQLOutputType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 196,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLUnmodifiedType",
+            "desc": "(Lgraphql/schema/GraphQLUnmodifiedType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 202,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "changeNode",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLSchemaElement;)Lgraphql/util/TraversalControl;",
+            "line": 208,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "deleteNode",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 213,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "insertAfter",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLSchemaElement;)Lgraphql/util/TraversalControl;",
+            "line": 218,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "insertBefore",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLSchemaElement;)Lgraphql/util/TraversalControl;",
+            "line": 223,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLUnmodifiedType$0",
+            "desc": "(Lgraphql/schema/GraphQLUnmodifiedType;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 202,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLOutputType$0",
+            "desc": "(Lgraphql/schema/GraphQLOutputType;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 196,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLNullableType$0",
+            "desc": "(Lgraphql/schema/GraphQLNullableType;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLInputType$0",
+            "desc": "(Lgraphql/schema/GraphQLInputType;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 184,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLInputFieldsContainer$0",
+            "desc": "(Lgraphql/schema/GraphQLInputFieldsContainer;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 178,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLFieldsContainer$0",
+            "desc": "(Lgraphql/schema/GraphQLFieldsContainer;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 172,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLDirectiveContainer$0",
+            "desc": "(Lgraphql/schema/GraphQLDirectiveContainer;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 166,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLCompositeType$0",
+            "desc": "(Lgraphql/schema/GraphQLCompositeType;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 160,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLModifiedType$0",
+            "desc": "(Lgraphql/schema/GraphQLModifiedType;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 154,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$visitBackRef$0",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 148,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLUnionType$0",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 142,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLTypeReference$0",
+            "desc": "(Lgraphql/schema/GraphQLTypeReference;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLScalarType$0",
+            "desc": "(Lgraphql/schema/GraphQLScalarType;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLObjectType$0",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 124,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLNonNull$0",
+            "desc": "(Lgraphql/schema/GraphQLNonNull;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 118,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLList$0",
+            "desc": "(Lgraphql/schema/GraphQLList;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLInputObjectType$0",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 106,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLInputObjectField$0",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLDirective$0",
+            "desc": "(Lgraphql/schema/GraphQLDirective;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLFieldDefinition$0",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLEnumValueDefinition$0",
+            "desc": "(Lgraphql/schema/GraphQLEnumValueDefinition;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLEnumType$0",
+            "desc": "(Lgraphql/schema/GraphQLEnumType;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLInterfaceType$0",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLArgument$0",
+            "desc": "(Lgraphql/schema/GraphQLArgument;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLAppliedDirectiveArgument$0",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirectiveArgument;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLAppliedDirective$0",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirective;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.impl.GraphQLTypeCollectingVisitor": {
+        "line": {
+          "covered": 60,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 12,
+          "missed": 0
+        },
+        "method": {
+          "covered": 18,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLEnumType",
+            "desc": "(Lgraphql/schema/GraphQLEnumType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLScalarType",
+            "desc": "(Lgraphql/schema/GraphQLScalarType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLObjectType",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputObjectType",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInterfaceType",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLUnionType",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 106,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputObjectField",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLArgument",
+            "desc": "(Lgraphql/schema/GraphQLArgument;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 118,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLAppliedDirectiveArgument",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirectiveArgument;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 124,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "saveIndirectStrongReference",
+            "desc": "(Ljava/util/function/Supplier;)V",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "save",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLNamedType;)V",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertTypeUniqueness",
+            "desc": "(Lgraphql/schema/GraphQLNamedType;Ljava/util/Map;)V",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertUniqueTypeObjects",
+            "desc": "(Lgraphql/schema/GraphQLNamedType;Lgraphql/schema/GraphQLNamedType;)V",
+            "line": 148,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getResult",
+            "desc": "()Lcom/google/common/collect/ImmutableMap;",
+            "line": 157,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fixDanglingReplacedTypes",
+            "desc": "(Ljava/util/Map;)Ljava/util/Map;",
+            "line": 194,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$fixDanglingReplacedTypes$0",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;)Ljava/util/List;",
+            "line": 210,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.impl.StronglyConnectedComponentsTopologicallySorted": {
+        "line": {
+          "covered": 72,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 31,
+          "missed": 1
+        },
+        "method": {
+          "covered": 6,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Map;Ljava/util/Map;)V",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getStronglyConnectedComponentsTopologicallySorted",
+            "desc": "(Ljava/util/Map;Ljava/util/Map;)Ljava/util/List;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "calculate",
+            "desc": "()V",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "stronglyConnect",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;)V",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 28,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 16,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "topologicallySort",
+            "desc": "(Ljava/util/Set;)Ljava/util/List;",
+            "line": 106,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visit",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;Ljava/util/Set;Ljava/util/Set;Ljava/util/Set;Ljava/util/List;Ljava/util/Set;)V",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 9,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.impl.SchemaUtil": {
+        "line": {
+          "covered": 56,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 26,
+          "missed": 6
+        },
+        "method": {
+          "covered": 10,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitPartiallySchema",
+            "desc": "(Lgraphql/schema/GraphQLSchema;[Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "groupInterfaceImplementationsByName",
+            "desc": "(Ljava/util/List;)Lcom/google/common/collect/ImmutableMap;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "groupImplementationsForInterfacesAndObjects",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Ljava/util/Map;",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceTypeReferences",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)V",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOperationRootType",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/OperationDefinition;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 109,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 4
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$replaceTypeReferences$0",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;)Ljava/util/List;",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$groupImplementationsForInterfacesAndObjects$0",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$groupInterfaceImplementationsByName$0",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitPartiallySchema$0",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;)Ljava/util/List;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.ChainedInstrumentation$ChainedDeferredExecutionStrategyInstrumentationContext": {
+        "line": {
+          "covered": 0,
+          "missed": 7
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 0,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;)V",
+            "line": 395,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "onDispatched",
+            "desc": "()V",
+            "line": 401,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "onCompleted",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Throwable;)V",
+            "line": 406,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$onCompleted$0",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Throwable;Lgraphql/execution/instrumentation/InstrumentationContext;)V",
+            "line": 406,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.FieldFetchingInstrumentationContext$2": {
+        "line": {
+          "covered": 5,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/instrumentation/InstrumentationContext;)V",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onDispatched",
+            "desc": "()V",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onCompleted",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Throwable;)V",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.FieldFetchingInstrumentationContext$1": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onDispatched",
+            "desc": "()V",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onCompleted",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Throwable;)V",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.DocumentAndVariables$Builder": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "document",
+            "desc": "(Lgraphql/language/Document;)Lgraphql/execution/instrumentation/DocumentAndVariables$Builder;",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "variables",
+            "desc": "(Ljava/util/Map;)Lgraphql/execution/instrumentation/DocumentAndVariables$Builder;",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/execution/instrumentation/DocumentAndVariables;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.SimpleInstrumentationContext": {
+        "line": {
+          "covered": 16,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 2
+        },
+        "method": {
+          "covered": 9,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "noOp",
+            "desc": "()Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "nonNullCtx",
+            "desc": "(Lgraphql/execution/instrumentation/InstrumentationContext;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Runnable;Ljava/util/function/BiConsumer;)V",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onDispatched",
+            "desc": "()V",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onCompleted",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Throwable;)V",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "whenDispatched",
+            "desc": "(Ljava/lang/Runnable;)Lgraphql/execution/instrumentation/SimpleInstrumentationContext;",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "whenCompleted",
+            "desc": "(Ljava/util/function/BiConsumer;)Lgraphql/execution/instrumentation/SimpleInstrumentationContext;",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "completeInstrumentationCtxCF",
+            "desc": "(Lgraphql/execution/instrumentation/InstrumentationContext;)Ljava/util/function/BiConsumer;",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$completeInstrumentationCtxCF$0",
+            "desc": "(Lgraphql/execution/instrumentation/InstrumentationContext;Ljava/lang/Object;Ljava/lang/Throwable;)V",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.ExecuteObjectInstrumentationContext": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "nonNullCtx",
+            "desc": "(Lgraphql/execution/instrumentation/ExecuteObjectInstrumentationContext;)Lgraphql/execution/instrumentation/ExecuteObjectInstrumentationContext;",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onFieldValuesInfo",
+            "desc": "(Ljava/util/List;)V",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onFieldValuesException",
+            "desc": "()V",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.SimpleInstrumentationContext$1": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onDispatched",
+            "desc": "()V",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onCompleted",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Throwable;)V",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.ExecutionStrategyInstrumentationContext": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "onFieldValuesInfo",
+            "desc": "(Ljava/util/List;)V",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onFieldValuesException",
+            "desc": "()V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "nonNullCtx",
+            "desc": "(Lgraphql/execution/instrumentation/ExecutionStrategyInstrumentationContext;)Lgraphql/execution/instrumentation/ExecutionStrategyInstrumentationContext;",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.ChainedInstrumentation$ChainedInstrumentationState": {
+        "line": {
+          "covered": 10,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;)V",
+            "line": 265,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getState",
+            "desc": "(I)Lgraphql/execution/instrumentation/InstrumentationState;",
+            "line": 270,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "combineAll",
+            "desc": "(Ljava/util/List;Lgraphql/execution/instrumentation/parameters/InstrumentationCreateStateParameters;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 274,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.InstrumentationState": {
+        "line": {
+          "covered": 1,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "ofState",
+            "desc": "(Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationState;",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.Instrumentation": {
+        "line": {
+          "covered": 22,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 1,
+          "missed": 1
+        },
+        "method": {
+          "covered": 20,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "createStateAsync",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationCreateStateParameters;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createState",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationCreateStateParameters;)Lgraphql/execution/instrumentation/InstrumentationState;",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginExecution",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginParse",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginValidation",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationValidationParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginExecuteOperation",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecuteOperationParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginReactiveResults",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationReactiveResultsParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginExecutionStrategy",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionStrategyParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/ExecutionStrategyInstrumentationContext;",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginExecuteObject",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionStrategyParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/ExecuteObjectInstrumentationContext;",
+            "line": 164,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginDeferredField",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 180,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginSubscribedFieldEvent",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 193,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "beginFieldExecution",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 206,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginFieldFetch",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldFetchParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 223,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginFieldFetching",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldFetchParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/FieldFetchingInstrumentationContext;",
+            "line": 243,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginFieldCompletion",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldCompleteParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 257,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginFieldListCompletion",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldCompleteParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 270,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "instrumentExecutionInput",
+            "desc": "(Lgraphql/ExecutionInput;Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/ExecutionInput;",
+            "line": 285,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "instrumentDocumentAndVariables",
+            "desc": "(Lgraphql/execution/instrumentation/DocumentAndVariables;Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/DocumentAndVariables;",
+            "line": 299,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "instrumentSchema",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/schema/GraphQLSchema;",
+            "line": 314,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "instrumentExecutionContext",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/ExecutionContext;",
+            "line": 329,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "instrumentDataFetcher",
+            "desc": "(Lgraphql/schema/DataFetcher;Lgraphql/execution/instrumentation/parameters/InstrumentationFieldFetchParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/schema/DataFetcher;",
+            "line": 346,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "instrumentExecutionResult",
+            "desc": "(Lgraphql/ExecutionResult;Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 360,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.SimpleInstrumentation": {
+        "line": {
+          "covered": 0,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 0,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.SimplePerformantInstrumentation": {
+        "line": {
+          "covered": 22,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 21,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createStateAsync",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationCreateStateParameters;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createState",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationCreateStateParameters;)Lgraphql/execution/instrumentation/InstrumentationState;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginExecution",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginParse",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginValidation",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationValidationParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginExecuteOperation",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecuteOperationParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginExecutionStrategy",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionStrategyParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/ExecutionStrategyInstrumentationContext;",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginExecuteObject",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionStrategyParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/ExecuteObjectInstrumentationContext;",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginSubscribedFieldEvent",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginFieldExecution",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 97,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginFieldFetch",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldFetchParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginFieldCompletion",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldCompleteParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginFieldListCompletion",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldCompleteParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "instrumentExecutionInput",
+            "desc": "(Lgraphql/ExecutionInput;Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/ExecutionInput;",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "instrumentDocumentAndVariables",
+            "desc": "(Lgraphql/execution/instrumentation/DocumentAndVariables;Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/DocumentAndVariables;",
+            "line": 122,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "instrumentSchema",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/schema/GraphQLSchema;",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "instrumentExecutionContext",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/ExecutionContext;",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "instrumentDataFetcher",
+            "desc": "(Lgraphql/schema/DataFetcher;Lgraphql/execution/instrumentation/parameters/InstrumentationFieldFetchParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/schema/DataFetcher;",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "instrumentExecutionResult",
+            "desc": "(Lgraphql/ExecutionResult;Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 142,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.ExecuteObjectInstrumentationContext$1": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onDispatched",
+            "desc": "()V",
+            "line": 18,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onCompleted",
+            "desc": "(Ljava/util/Map;Ljava/lang/Throwable;)V",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.FieldFetchingInstrumentationContext": {
+        "line": {
+          "covered": 7,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "onFetchedValue",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onExceptionHandled",
+            "desc": "(Lgraphql/execution/DataFetcherResult;)V",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "nonNullCtx",
+            "desc": "(Lgraphql/execution/instrumentation/FieldFetchingInstrumentationContext;)Lgraphql/execution/instrumentation/FieldFetchingInstrumentationContext;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "adapter",
+            "desc": "(Lgraphql/execution/instrumentation/InstrumentationContext;)Lgraphql/execution/instrumentation/FieldFetchingInstrumentationContext;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.DocumentAndVariables": {
+        "line": {
+          "covered": 10,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Document;Ljava/util/Map;)V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDocument",
+            "desc": "()Lgraphql/language/Document;",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getVariables",
+            "desc": "()Ljava/util/Map;",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/execution/instrumentation/DocumentAndVariables;",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newDocumentAndVariables",
+            "desc": "()Lgraphql/execution/instrumentation/DocumentAndVariables$Builder;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.ChainedInstrumentation": {
+        "line": {
+          "covered": 79,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 28,
+          "missed": 0
+        },
+        "method": {
+          "covered": 41,
+          "missed": 8
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;)V",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "([Lgraphql/execution/instrumentation/Instrumentation;)V",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInstrumentations",
+            "desc": "()Ljava/util/List;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "chainedCtx",
+            "desc": "(Lgraphql/execution/instrumentation/InstrumentationState;Ljava/util/function/BiFunction;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "chainedInstrument",
+            "desc": "(Lgraphql/execution/instrumentation/InstrumentationState;Ljava/lang/Object;Lgraphql/execution/instrumentation/ChainedInstrumentation$ChainedInstrumentationFunction;)Ljava/lang/Object;",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "chainedMapAndDropNulls",
+            "desc": "(Lgraphql/execution/instrumentation/InstrumentationState;Ljava/util/function/BiFunction;)Lcom/google/common/collect/ImmutableList;",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "chainedConsume",
+            "desc": "(Lgraphql/execution/instrumentation/InstrumentationState;Ljava/util/function/BiConsumer;)V",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createStateAsync",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationCreateStateParameters;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 118,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginExecution",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 123,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginParse",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginValidation",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationValidationParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 135,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginExecuteOperation",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecuteOperationParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginReactiveResults",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationReactiveResultsParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 145,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "beginExecutionStrategy",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionStrategyParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/ExecutionStrategyInstrumentationContext;",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginExecuteObject",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionStrategyParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/ExecuteObjectInstrumentationContext;",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginDeferredField",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 177,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "beginSubscribedFieldEvent",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 182,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "beginFieldExecution",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 187,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginFieldFetch",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldFetchParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 193,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "beginFieldFetching",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldFetchParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/FieldFetchingInstrumentationContext;",
+            "line": 198,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginFieldCompletion",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldCompleteParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 212,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginFieldListCompletion",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldCompleteParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 218,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "instrumentExecutionInput",
+            "desc": "(Lgraphql/ExecutionInput;Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/ExecutionInput;",
+            "line": 223,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "instrumentDocumentAndVariables",
+            "desc": "(Lgraphql/execution/instrumentation/DocumentAndVariables;Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/DocumentAndVariables;",
+            "line": 228,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "instrumentSchema",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/schema/GraphQLSchema;",
+            "line": 234,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "instrumentExecutionContext",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/ExecutionContext;",
+            "line": 240,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "instrumentDataFetcher",
+            "desc": "(Lgraphql/schema/DataFetcher;Lgraphql/execution/instrumentation/parameters/InstrumentationFieldFetchParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/schema/DataFetcher;",
+            "line": 246,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "instrumentExecutionResult",
+            "desc": "(Lgraphql/ExecutionResult;Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 252,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$instrumentExecutionResult$1",
+            "desc": "(Lgraphql/ExecutionResult;Ljava/util/List;)Lgraphql/ExecutionResult;",
+            "line": 259,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$instrumentExecutionResult$0",
+            "desc": "(Lgraphql/ExecutionResult;Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Ljava/util/Map$Entry;Ljava/util/List;)Ljava/lang/Object;",
+            "line": 254,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$instrumentDataFetcher$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldFetchParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;Lgraphql/schema/DataFetcher;)Lgraphql/schema/DataFetcher;",
+            "line": 247,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$instrumentExecutionContext$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;Lgraphql/execution/ExecutionContext;)Lgraphql/execution/ExecutionContext;",
+            "line": 241,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$instrumentSchema$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;Lgraphql/schema/GraphQLSchema;)Lgraphql/schema/GraphQLSchema;",
+            "line": 235,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$instrumentDocumentAndVariables$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;Lgraphql/execution/instrumentation/DocumentAndVariables;)Lgraphql/execution/instrumentation/DocumentAndVariables;",
+            "line": 229,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$instrumentExecutionInput$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;Lgraphql/ExecutionInput;)Lgraphql/ExecutionInput;",
+            "line": 223,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$beginFieldListCompletion$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldCompleteParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 218,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$beginFieldCompletion$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldCompleteParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 212,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$beginFieldFetching$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldFetchParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/FieldFetchingInstrumentationContext;",
+            "line": 201,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$beginFieldFetch$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldFetchParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 193,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$beginFieldExecution$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 187,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$beginSubscribedFieldEvent$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 182,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$beginDeferredField$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 177,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$beginExecuteObject$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionStrategyParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/ExecuteObjectInstrumentationContext;",
+            "line": 166,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$beginExecutionStrategy$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionStrategyParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/ExecutionStrategyInstrumentationContext;",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$beginReactiveResults$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationReactiveResultsParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 145,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$beginExecuteOperation$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecuteOperationParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$beginValidation$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationValidationParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 135,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$beginParse$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$beginExecution$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 123,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.ExecutionStrategyInstrumentationContext$1": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onDispatched",
+            "desc": "()V",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onCompleted",
+            "desc": "(Lgraphql/ExecutionResult;Ljava/lang/Throwable;)V",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.ChainedInstrumentation$ChainedExecuteObjectInstrumentationContext": {
+        "line": {
+          "covered": 9,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lcom/google/common/collect/ImmutableList;)V",
+            "line": 336,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onDispatched",
+            "desc": "()V",
+            "line": 342,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onCompleted",
+            "desc": "(Ljava/util/Map;Ljava/lang/Throwable;)V",
+            "line": 347,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onFieldValuesInfo",
+            "desc": "(Ljava/util/List;)V",
+            "line": 352,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onFieldValuesException",
+            "desc": "()V",
+            "line": 357,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$onFieldValuesInfo$0",
+            "desc": "(Ljava/util/List;Lgraphql/execution/instrumentation/ExecuteObjectInstrumentationContext;)V",
+            "line": 352,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$onCompleted$0",
+            "desc": "(Ljava/util/Map;Ljava/lang/Throwable;Lgraphql/execution/instrumentation/ExecuteObjectInstrumentationContext;)V",
+            "line": 347,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.ChainedInstrumentation$ChainedInstrumentationContext": {
+        "line": {
+          "covered": 7,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lcom/google/common/collect/ImmutableList;)V",
+            "line": 288,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onDispatched",
+            "desc": "()V",
+            "line": 294,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onCompleted",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Throwable;)V",
+            "line": 299,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$onCompleted$0",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Throwable;Lgraphql/execution/instrumentation/InstrumentationContext;)V",
+            "line": 299,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.NoContextChainedInstrumentation": {
+        "line": {
+          "covered": 13,
+          "missed": 7
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 20,
+          "missed": 11
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;)V",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "([Lgraphql/execution/instrumentation/Instrumentation;)V",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "runAll",
+            "desc": "(Lgraphql/execution/instrumentation/InstrumentationState;Ljava/util/function/BiConsumer;)Ljava/lang/Object;",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginExecution",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginParse",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginValidation",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationValidationParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginExecuteOperation",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecuteOperationParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginReactiveResults",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationReactiveResultsParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "beginExecutionStrategy",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionStrategyParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/ExecutionStrategyInstrumentationContext;",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginExecuteObject",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionStrategyParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/ExecuteObjectInstrumentationContext;",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginDeferredField",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "beginSubscribedFieldEvent",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "beginFieldExecution",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 106,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginFieldFetch",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldFetchParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "beginFieldFetching",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldFetchParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/FieldFetchingInstrumentationContext;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginFieldCompletion",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldCompleteParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginFieldListCompletion",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldCompleteParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$beginFieldListCompletion$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldCompleteParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)V",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$beginFieldCompletion$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldCompleteParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)V",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$beginFieldFetching$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldFetchParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)V",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$beginFieldFetch$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldFetchParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)V",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$beginFieldExecution$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)V",
+            "line": 106,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$beginSubscribedFieldEvent$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)V",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$beginDeferredField$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)V",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$beginExecuteObject$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionStrategyParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)V",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$beginExecutionStrategy$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionStrategyParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)V",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$beginReactiveResults$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationReactiveResultsParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)V",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$beginExecuteOperation$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecuteOperationParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)V",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$beginValidation$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationValidationParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)V",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$beginParse$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)V",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$beginExecution$0",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/InstrumentationState;)V",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.ChainedInstrumentation$ChainedExecutionStrategyInstrumentationContext": {
+        "line": {
+          "covered": 9,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lcom/google/common/collect/ImmutableList;)V",
+            "line": 307,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onDispatched",
+            "desc": "()V",
+            "line": 313,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onCompleted",
+            "desc": "(Lgraphql/ExecutionResult;Ljava/lang/Throwable;)V",
+            "line": 318,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onFieldValuesInfo",
+            "desc": "(Ljava/util/List;)V",
+            "line": 323,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onFieldValuesException",
+            "desc": "()V",
+            "line": 328,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$onFieldValuesInfo$0",
+            "desc": "(Ljava/util/List;Lgraphql/execution/instrumentation/ExecutionStrategyInstrumentationContext;)V",
+            "line": 323,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$onCompleted$0",
+            "desc": "(Lgraphql/ExecutionResult;Ljava/lang/Throwable;Lgraphql/execution/instrumentation/ExecutionStrategyInstrumentationContext;)V",
+            "line": 318,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.ChainedInstrumentation$ChainedFieldFetchingInstrumentationContext": {
+        "line": {
+          "covered": 11,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 8,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lcom/google/common/collect/ImmutableList;)V",
+            "line": 365,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onDispatched",
+            "desc": "()V",
+            "line": 371,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onFetchedValue",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 376,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onExceptionHandled",
+            "desc": "(Lgraphql/execution/DataFetcherResult;)V",
+            "line": 381,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onCompleted",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Throwable;)V",
+            "line": 386,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$onCompleted$0",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Throwable;Lgraphql/execution/instrumentation/FieldFetchingInstrumentationContext;)V",
+            "line": 386,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$onExceptionHandled$0",
+            "desc": "(Lgraphql/execution/DataFetcherResult;Lgraphql/execution/instrumentation/FieldFetchingInstrumentationContext;)V",
+            "line": 381,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$onFetchedValue$0",
+            "desc": "(Ljava/lang/Object;Lgraphql/execution/instrumentation/FieldFetchingInstrumentationContext;)V",
+            "line": 376,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.querygenerator.QueryGenerator": {
+        "line": {
+          "covered": 51,
+          "missed": 11
+        },
+        "branch": {
+          "covered": 22,
+          "missed": 6
+        },
+        "method": {
+          "covered": 6,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)V",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 5
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/util/querygenerator/QueryGeneratorOptions;)V",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "generateQuery",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Lgraphql/util/querygenerator/QueryGeneratorResult;",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 46,
+                "missed": 6
+              },
+              "branch": {
+                "covered": 22,
+                "missed": 6
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$generateQuery$3",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLOutputType;)Ljava/lang/IllegalArgumentException;",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$generateQuery$2",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLFieldsContainer;)Z",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$generateQuery$1",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLOutputType;)Ljava/lang/IllegalArgumentException;",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$generateQuery$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLFieldsContainer;)Z",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.querygenerator.QueryGeneratorFieldSelection$FieldSelection": {
+        "line": {
+          "covered": 5,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/Map;Z)V",
+            "line": 179,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.querygenerator.QueryGeneratorOptions$QueryGeneratorOptionsBuilder": {
+        "line": {
+          "covered": 17,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 8,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "alwaysTrue",
+            "desc": "()Ljava/util/function/Predicate;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "maxFieldCount",
+            "desc": "(I)Lgraphql/util/querygenerator/QueryGeneratorOptions$QueryGeneratorOptionsBuilder;",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filterFieldContainerPredicate",
+            "desc": "(Ljava/util/function/Predicate;)Lgraphql/util/querygenerator/QueryGeneratorOptions$QueryGeneratorOptionsBuilder;",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filterFieldDefinitionPredicate",
+            "desc": "(Ljava/util/function/Predicate;)Lgraphql/util/querygenerator/QueryGeneratorOptions$QueryGeneratorOptionsBuilder;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/util/querygenerator/QueryGeneratorOptions;",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$0",
+            "desc": "(Ljava/lang/Object;)Z",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.querygenerator.QueryGeneratorFieldSelection$FieldSelectionResult": {
+        "line": {
+          "covered": 5,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/util/querygenerator/QueryGeneratorFieldSelection$FieldSelection;Ljava/lang/Integer;Ljava/lang/Boolean;)V",
+            "line": 191,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.querygenerator.QueryGeneratorFieldSelection": {
+        "line": {
+          "covered": 74,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 38,
+          "missed": 0
+        },
+        "method": {
+          "covered": 11,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/util/querygenerator/QueryGeneratorOptions;)V",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildFields",
+            "desc": "(Lgraphql/schema/GraphQLFieldsContainer;)Lgraphql/util/querygenerator/QueryGeneratorFieldSelection$FieldSelectionResult;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "processContainers",
+            "desc": "(Ljava/util/Queue;Ljava/util/Queue;Ljava/util/Set;Ljava/util/concurrent/atomic/AtomicInteger;)V",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 20,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 14,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "processField",
+            "desc": "(Lgraphql/schema/GraphQLFieldsContainer;Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/util/querygenerator/QueryGeneratorFieldSelection$FieldSelection;Ljava/util/Queue;Ljava/util/Queue;Lgraphql/schema/FieldCoordinates;Ljava/util/Set;Ljava/util/concurrent/atomic/AtomicInteger;)V",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 23,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldSelection",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/GraphQLType;)Lgraphql/util/querygenerator/QueryGeneratorFieldSelection$FieldSelection;",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasRequiredArgs",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;)Z",
+            "line": 170,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$hasRequiredArgs$0",
+            "desc": "(Lgraphql/schema/GraphQLArgument;)Z",
+            "line": 171,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$processField$2",
+            "desc": "(Lgraphql/schema/GraphQLNamedOutputType;)Lgraphql/schema/GraphQLFieldsContainer;",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$processField$1",
+            "desc": "(Lgraphql/schema/GraphQLNamedOutputType;)Z",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$processField$0",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 123,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.querygenerator.QueryGeneratorPrinter": {
+        "line": {
+          "covered": 56,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 25,
+          "missed": 1
+        },
+        "method": {
+          "covered": 10,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 10,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "print",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Lgraphql/util/querygenerator/QueryGeneratorFieldSelection$FieldSelection;)Ljava/lang/String;",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printFieldsForTopLevelType",
+            "desc": "(Lgraphql/util/querygenerator/QueryGeneratorFieldSelection$FieldSelection;)Ljava/lang/String;",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printOperationStart",
+            "desc": "([Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printOperationEnd",
+            "desc": "([Ljava/lang/String;)Ljava/lang/String;",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printFieldSelectionForContainer",
+            "desc": "(Ljava/lang/String;Ljava/util/List;Z)Ljava/lang/String;",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printFieldSelection",
+            "desc": "(Lgraphql/util/querygenerator/QueryGeneratorFieldSelection$FieldSelection;Ljava/lang/String;)Ljava/lang/String;",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printFieldSelection",
+            "desc": "(Lgraphql/util/querygenerator/QueryGeneratorFieldSelection$FieldSelection;)Ljava/lang/String;",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$printFieldSelection$0",
+            "desc": "(Lgraphql/util/querygenerator/QueryGeneratorFieldSelection$FieldSelection;Ljava/util/Map$Entry;)Ljava/lang/String;",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$printFieldSelectionForContainer$0",
+            "desc": "(ZLjava/lang/String;Lgraphql/util/querygenerator/QueryGeneratorFieldSelection$FieldSelection;)Ljava/lang/String;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.querygenerator.QueryGeneratorOptions": {
+        "line": {
+          "covered": 9,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(ILjava/util/function/Predicate;Ljava/util/function/Predicate;)V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMaxFieldCount",
+            "desc": "()I",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFilterFieldContainerPredicate",
+            "desc": "()Ljava/util/function/Predicate;",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFilterFieldDefinitionPredicate",
+            "desc": "()Ljava/util/function/Predicate;",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newBuilder",
+            "desc": "()Lgraphql/util/querygenerator/QueryGeneratorOptions$QueryGeneratorOptionsBuilder;",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.querygenerator.QueryGeneratorResult": {
+        "line": {
+          "covered": 10,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;IZ)V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getQuery",
+            "desc": "()Ljava/lang/String;",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getUsedType",
+            "desc": "()Ljava/lang/String;",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTotalFieldCount",
+            "desc": "()I",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isReachedMaxFieldCount",
+            "desc": "()Z",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.incremental.DeferredFragmentCall": {
+        "line": {
+          "covered": 39,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 5,
+          "missed": 1
+        },
+        "method": {
+          "covered": 6,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "getPath",
+            "desc": "()Lgraphql/execution/ResultPath;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/execution/ResultPath;Ljava/util/List;Lgraphql/execution/incremental/AlternativeCallContext;)V",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "invoke",
+            "desc": "()Ljava/util/concurrent/CompletableFuture;",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleNonNullableFieldError",
+            "desc": "(Lgraphql/incremental/DeferPayload;Ljava/lang/Throwable;)Lgraphql/incremental/DeferPayload;",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transformToDeferredPayload",
+            "desc": "(Ljava/util/List;)Lgraphql/incremental/DeferPayload;",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$transformToDeferredPayload$0",
+            "desc": "(Ljava/util/Map;Lcom/google/common/collect/ImmutableList$Builder;Lgraphql/execution/incremental/DeferredFragmentCall$FieldWithExecutionResult;)V",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$invoke$0",
+            "desc": "(Lgraphql/execution/Async$CombinedBuilder;Ljava/util/function/Supplier;)V",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.incremental.DeferredExecutionSupport$NoOp": {
+        "line": {
+          "covered": 5,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 214,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isDeferredField",
+            "desc": "(Lgraphql/execution/MergedField;)Z",
+            "line": 218,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deferredFieldsCount",
+            "desc": "()I",
+            "line": 223,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNonDeferredFieldNames",
+            "desc": "(Ljava/util/List;)Ljava/util/List;",
+            "line": 228,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createCalls",
+            "desc": "()Ljava/util/Set;",
+            "line": 233,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.incremental.DeferredExecution": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLabel",
+            "desc": "()Ljava/lang/String;",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.incremental.AlternativeCallContext": {
+        "line": {
+          "covered": 16,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(II)V",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getStartLevel",
+            "desc": "()I",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFields",
+            "desc": "()I",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addErrors",
+            "desc": "(Ljava/util/List;)V",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addError",
+            "desc": "(Lgraphql/GraphQLError;)V",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrors",
+            "desc": "()Ljava/util/List;",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.incremental.IncrementalCallState": {
+        "line": {
+          "covered": 40,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 8,
+          "missed": 0
+        },
+        "method": {
+          "covered": 11,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "drainIncrementalCalls",
+            "desc": "()V",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enqueue",
+            "desc": "(Lgraphql/execution/incremental/IncrementalCall;)V",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enqueue",
+            "desc": "(Ljava/util/Collection;)V",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getIncrementalCallsDetected",
+            "desc": "()Z",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createPublisher",
+            "desc": "()Ljava/util/function/Supplier;",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "startDeferredCalls",
+            "desc": "()Lorg/reactivestreams/Publisher;",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "startDrainingNow",
+            "desc": "()V",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$createPublisher$0",
+            "desc": "()Lgraphql/execution/reactive/SingleSubscriberPublisher;",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$enqueue$0",
+            "desc": "(Lgraphql/execution/incremental/IncrementalCall;)V",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$drainIncrementalCalls$0",
+            "desc": "(Lgraphql/incremental/IncrementalPayload;Ljava/lang/Throwable;)V",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.incremental.StreamedCall": {
+        "line": {
+          "covered": 0,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 0,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 14,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "invoke",
+            "desc": "()Ljava/util/concurrent/CompletableFuture;",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.incremental.DeferredFragmentCall$FieldWithExecutionResult": {
+        "line": {
+          "covered": 4,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/ExecutionResult;)V",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExecutionResult",
+            "desc": "()Lgraphql/ExecutionResult;",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.incremental.IncrementalUtils": {
+        "line": {
+          "covered": 13,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 6,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "createDeferredExecution",
+            "desc": "(Ljava/util/Map;Ljava/util/List;Ljava/util/function/Function;)Ljava/lang/Object;",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.incremental.DeferredExecutionSupport": {
+        "line": {
+          "covered": 1,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.incremental.DeferredExecutionSupport$DeferredExecutionSupportImpl": {
+        "line": {
+          "covered": 74,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 6,
+          "missed": 0
+        },
+        "method": {
+          "covered": 17,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/MergedSelectionSet;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/execution/ExecutionContext;Ljava/util/function/BiFunction;Ljava/util/function/BiFunction;)V",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isDeferredField",
+            "desc": "(Lgraphql/execution/MergedField;)Z",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deferredFieldsCount",
+            "desc": "()I",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNonDeferredFieldNames",
+            "desc": "(Ljava/util/List;)Ljava/util/List;",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createCalls",
+            "desc": "()Ljava/util/Set;",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createDeferredFragmentCall",
+            "desc": "(Lgraphql/execution/incremental/DeferredExecution;)Lgraphql/execution/incremental/DeferredFragmentCall;",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createResultSupplier",
+            "desc": "(Lgraphql/execution/MergedField;Lgraphql/execution/incremental/AlternativeCallContext;)Ljava/util/function/Supplier;",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "resolveDeferredFieldValue",
+            "desc": "(Lgraphql/execution/MergedField;Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;)Ljava/util/function/Supplier;",
+            "line": 178,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$resolveDeferredFieldValue$0",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/execution/MergedField;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 180,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$resolveDeferredFieldValue$4",
+            "desc": "(Lgraphql/execution/MergedField;Lgraphql/ExecutionResult;)Lgraphql/execution/incremental/DeferredFragmentCall$FieldWithExecutionResult;",
+            "line": 205,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$resolveDeferredFieldValue$2",
+            "desc": "(Lgraphql/execution/FieldValueInfo;)Ljava/util/concurrent/CompletionStage;",
+            "line": 198,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$resolveDeferredFieldValue$3",
+            "desc": "(Ljava/lang/Object;)Lgraphql/ExecutionResult;",
+            "line": 200,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$resolveDeferredFieldValue$1",
+            "desc": "(Lgraphql/execution/MergedField;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/execution/instrumentation/InstrumentationContext;Lgraphql/execution/FieldValueInfo;Ljava/lang/Throwable;)V",
+            "line": 192,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$createResultSupplier$1",
+            "desc": "(Lgraphql/execution/MergedField;Lgraphql/execution/ExecutionStrategyParameters;Ljava/lang/String;)Ljava/util/function/Supplier;",
+            "line": 171,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$createResultSupplier$0",
+            "desc": "(Ljava/util/Map;Lgraphql/execution/MergedField;Lgraphql/execution/incremental/AlternativeCallContext;Lgraphql/execution/ExecutionStrategyParameters$Builder;)V",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$0",
+            "desc": "(Lcom/google/common/collect/ImmutableList$Builder;Lcom/google/common/collect/ImmutableListMultimap$Builder;Lcom/google/common/collect/ImmutableSet$Builder;Lgraphql/execution/MergedField;)V",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$1",
+            "desc": "(Lcom/google/common/collect/ImmutableListMultimap$Builder;Lgraphql/execution/MergedField;Lcom/google/common/collect/ImmutableSet$Builder;Lgraphql/execution/incremental/DeferredExecution;)V",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diff.reporting.PrintStreamReporter": {
+        "line": {
+          "covered": 26,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 10,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/io/PrintStream;)V",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "report",
+            "desc": "(Lgraphql/schema/diff/DiffEvent;)V",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printEvent",
+            "desc": "(Lgraphql/schema/diff/DiffEvent;)V",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onEnd",
+            "desc": "()V",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diff.reporting.ChainedReporter": {
+        "line": {
+          "covered": 9,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "([Lgraphql/schema/diff/reporting/DifferenceReporter;)V",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;)V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "report",
+            "desc": "(Lgraphql/schema/diff/DiffEvent;)V",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onEnd",
+            "desc": "()V",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$report$0",
+            "desc": "(Lgraphql/schema/diff/DiffEvent;Lgraphql/schema/diff/reporting/DifferenceReporter;)V",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diff.reporting.CapturingReporter": {
+        "line": {
+          "covered": 21,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 5,
+          "missed": 1
+        },
+        "method": {
+          "covered": 10,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 14,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "report",
+            "desc": "(Lgraphql/schema/diff/DiffEvent;)V",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onEnd",
+            "desc": "()V",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getEvents",
+            "desc": "()Ljava/util/List;",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInfos",
+            "desc": "()Ljava/util/List;",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getBreakages",
+            "desc": "()Ljava/util/List;",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDangers",
+            "desc": "()Ljava/util/List;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInfoCount",
+            "desc": "()I",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getBreakageCount",
+            "desc": "()I",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDangerCount",
+            "desc": "()I",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.ProfilerImpl": {
+        "line": {
+          "covered": 60,
+          "missed": 19
+        },
+        "branch": {
+          "covered": 29,
+          "missed": 13
+        },
+        "method": {
+          "covered": 7,
+          "missed": 5
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/GraphQLContext;)V",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setExecutionInputAndInstrumentation",
+            "desc": "(Lgraphql/ExecutionInput;Lgraphql/execution/instrumentation/Instrumentation;)V",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "collectInstrumentationClasses",
+            "desc": "(Ljava/util/List;Lgraphql/execution/instrumentation/Instrumentation;)V",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldFetched",
+            "desc": "(Ljava/lang/Object;Lgraphql/schema/DataFetcher;Lgraphql/schema/DataFetcher;Lgraphql/execution/ResultPath;Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/GraphQLOutputType;)V",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 24,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 18,
+                "missed": 4
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "wrapEngineRunningObserver",
+            "desc": "(Lgraphql/execution/EngineRunningObserver;)Lgraphql/execution/EngineRunningObserver;",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "runningStateChangedImpl",
+            "desc": "(Lgraphql/execution/ExecutionId;Lgraphql/GraphQLContext;Lgraphql/execution/EngineRunningObserver$RunningState;)V",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "operationDefinition",
+            "desc": "(Lgraphql/language/OperationDefinition;)V",
+            "line": 135,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "dataLoaderUsed",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "oldStrategyDispatchingAll",
+            "desc": "(I)V",
+            "line": 145,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "batchLoadedOldStrategy",
+            "desc": "(Ljava/lang/String;II)V",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "batchLoadedNewStrategy",
+            "desc": "(Ljava/lang/String;Ljava/lang/Integer;IZZ)V",
+            "line": 155,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 10
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 8
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "manualDispatch",
+            "desc": "(Ljava/lang/String;II)V",
+            "line": 170,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.TypeMismatchError": {
+        "line": {
+          "covered": 12,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/ResultPath;Lgraphql/schema/GraphQLType;)V",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkMessage",
+            "desc": "(Lgraphql/execution/ResultPath;Lgraphql/schema/GraphQLType;)Ljava/lang/String;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMessage",
+            "desc": "()Ljava/lang/String;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocations",
+            "desc": "()Ljava/util/List;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/ErrorType;",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPath",
+            "desc": "()Ljava/util/List;",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.ParseAndValidateResult": {
+        "line": {
+          "covered": 23,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 9,
+          "missed": 3
+        },
+        "method": {
+          "covered": 10,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/ParseAndValidateResult$Builder;)V",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isFailure",
+            "desc": "()Z",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDocument",
+            "desc": "()Lgraphql/language/Document;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getVariables",
+            "desc": "()Ljava/util/Map;",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDocumentAndVariables",
+            "desc": "()Lgraphql/execution/instrumentation/DocumentAndVariables;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSyntaxException",
+            "desc": "()Lgraphql/parser/InvalidSyntaxException;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getValidationErrors",
+            "desc": "()Ljava/util/List;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrors",
+            "desc": "()Ljava/util/List;",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/ParseAndValidateResult;",
+            "line": 97,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newResult",
+            "desc": "()Lgraphql/ParseAndValidateResult$Builder;",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.EngineRunningState": {
+        "line": {
+          "covered": 90,
+          "missed": 19
+        },
+        "branch": {
+          "covered": 30,
+          "missed": 12
+        },
+        "method": {
+          "covered": 23,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/ExecutionInput;Lgraphql/Profiler;)V",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handle",
+            "desc": "(Ljava/util/concurrent/CompletableFuture;Ljava/util/function/BiFunction;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "whenComplete",
+            "desc": "(Ljava/util/concurrent/CompletableFuture;Ljava/util/function/BiConsumer;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 6
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "compose",
+            "desc": "(Ljava/util/concurrent/CompletableFuture;Ljava/util/function/Function;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "observeCompletableFutureStart",
+            "desc": "(Ljava/util/concurrent/CompletableFuture;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "observerCompletableFutureEnd",
+            "desc": "(Ljava/util/concurrent/CompletableFuture;)V",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "incrementRunningWhenCompleted",
+            "desc": "(Ljava/util/concurrent/CompletableFuture;)V",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "decrementRunningWhenCompleted",
+            "desc": "(Ljava/util/concurrent/CompletableFuture;)V",
+            "line": 144,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "decrementRunning",
+            "desc": "()V",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "incrementRunning",
+            "desc": "()V",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "updateExecutionInput",
+            "desc": "(Lgraphql/ExecutionInput;)V",
+            "line": 174,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "changeOfState",
+            "desc": "(Lgraphql/execution/EngineRunningObserver$RunningState;)V",
+            "line": 179,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "run",
+            "desc": "(Ljava/lang/Runnable;)V",
+            "line": 185,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "engineRun",
+            "desc": "(Ljava/util/function/Supplier;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 201,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "throwIfCancelled",
+            "desc": "()V",
+            "line": 221,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "possibleCancellation",
+            "desc": "(Ljava/lang/Throwable;)Ljava/lang/Throwable;",
+            "line": 242,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ifCancelledMakeException",
+            "desc": "()Lgraphql/execution/AbortExecutionException;",
+            "line": 252,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$engineRun$0",
+            "desc": "(Lgraphql/ExecutionResult;Ljava/lang/Throwable;)V",
+            "line": 209,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$decrementRunningWhenCompleted$0",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Throwable;)V",
+            "line": 145,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$incrementRunningWhenCompleted$0",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Throwable;)V",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$compose$0",
+            "desc": "(Ljava/util/function/Function;Ljava/util/concurrent/CompletableFuture;Ljava/lang/Object;Ljava/lang/Throwable;)V",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$compose$1",
+            "desc": "(Ljava/util/concurrent/CompletableFuture;Ljava/lang/Object;Ljava/lang/Throwable;)V",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$compose$2",
+            "desc": "(Ljava/lang/Throwable;Ljava/util/concurrent/CompletableFuture;Ljava/lang/Object;)V",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$whenComplete$0",
+            "desc": "(Ljava/util/function/BiConsumer;Ljava/lang/Object;Ljava/lang/Throwable;)V",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$handle$0",
+            "desc": "(Ljava/util/function/BiFunction;Ljava/lang/Object;Ljava/lang/Throwable;)Ljava/lang/Object;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.DirectivesUtil": {
+        "line": {
+          "covered": 18,
+          "missed": 21
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 12
+        },
+        "method": {
+          "covered": 6,
+          "missed": 6
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "nonRepeatableDirectivesByName",
+            "desc": "(Ljava/util/List;)Ljava/util/Map;",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "allDirectivesByName",
+            "desc": "(Ljava/util/List;)Ljava/util/Map;",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "directiveWithArg",
+            "desc": "(Ljava/util/List;Ljava/lang/String;Ljava/lang/String;)Ljava/util/Optional;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isAllNonRepeatable",
+            "desc": "(Ljava/util/List;)Z",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 7
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 8
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "add",
+            "desc": "(Ljava/util/List;Lgraphql/schema/GraphQLDirective;)Ljava/util/List;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "addAll",
+            "desc": "(Ljava/util/List;Ljava/util/List;)Ljava/util/List;",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getFirstDirective",
+            "desc": "(Ljava/lang/String;Ljava/util/Map;)Lgraphql/schema/GraphQLDirective;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toAppliedDirectives",
+            "desc": "(Lgraphql/schema/GraphQLDirectiveContainer;)Ljava/util/List;",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toAppliedDirectives",
+            "desc": "(Ljava/util/Collection;Ljava/util/Collection;)Ljava/util/List;",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$toAppliedDirectives$0",
+            "desc": "(Ljava/util/Set;Lcom/google/common/collect/ImmutableList$Builder;Lgraphql/schema/GraphQLDirective;)V",
+            "line": 118,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$nonRepeatableDirectivesByName$0",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)Z",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.InvalidSyntaxError": {
+        "line": {
+          "covered": 16,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/SourceLocation;Ljava/lang/String;)V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;Ljava/lang/String;)V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMessage",
+            "desc": "()Ljava/lang/String;",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocations",
+            "desc": "()Ljava/util/List;",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSourcePreview",
+            "desc": "()Ljava/lang/String;",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getOffendingToken",
+            "desc": "()Ljava/lang/String;",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/ErrorType;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.UnresolvedTypeError": {
+        "line": {
+          "covered": 14,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/ResultPath;Lgraphql/execution/ExecutionStepInfo;Lgraphql/execution/UnresolvedTypeException;)V",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkMessage",
+            "desc": "(Lgraphql/execution/ResultPath;Lgraphql/execution/UnresolvedTypeException;Lgraphql/execution/ExecutionStepInfo;)Ljava/lang/String;",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getException",
+            "desc": "()Lgraphql/execution/UnresolvedTypeException;",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getMessage",
+            "desc": "()Ljava/lang/String;",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocations",
+            "desc": "()Ljava/util/List;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/ErrorType;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPath",
+            "desc": "()Ljava/util/List;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.GraphQLUnusualConfiguration$GoodFaithIntrospectionConfig": {
+        "line": {
+          "covered": 5,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/GraphQLUnusualConfiguration;)V",
+            "line": 213,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEnabledJvmWide",
+            "desc": "()Z",
+            "line": 220,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enabledJvmWide",
+            "desc": "(Z)Lgraphql/GraphQLUnusualConfiguration$GoodFaithIntrospectionConfig;",
+            "line": 231,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.GraphQLContext$Builder": {
+        "line": {
+          "covered": 21,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 12,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 324,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "put",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;)Lgraphql/GraphQLContext$Builder;",
+            "line": 330,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "get",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 336,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getBoolean",
+            "desc": "(Ljava/lang/Object;)Z",
+            "line": 340,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;)Lgraphql/GraphQLContext$Builder;",
+            "line": 347,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Lgraphql/GraphQLContext$Builder;",
+            "line": 356,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Lgraphql/GraphQLContext$Builder;",
+            "line": 367,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Lgraphql/GraphQLContext$Builder;",
+            "line": 380,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Lgraphql/GraphQLContext$Builder;",
+            "line": 395,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Ljava/util/Map;)Lgraphql/GraphQLContext$Builder;",
+            "line": 412,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "putAll",
+            "desc": "(Ljava/util/Map;)Lgraphql/GraphQLContext$Builder;",
+            "line": 427,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Lgraphql/GraphQLContext;)Lgraphql/GraphQLContext$Builder;",
+            "line": 438,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Lgraphql/GraphQLContext$Builder;)Lgraphql/GraphQLContext$Builder;",
+            "line": 450,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "putImpl",
+            "desc": "([Ljava/lang/Object;)Lgraphql/GraphQLContext$Builder;",
+            "line": 455,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/GraphQLContext;",
+            "line": 464,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.TypeResolutionEnvironment": {
+        "line": {
+          "covered": 20,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 11,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/TypeResolutionParameters;)V",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getObject",
+            "desc": "()Ljava/lang/Object;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArguments",
+            "desc": "()Ljava/util/Map;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getField",
+            "desc": "()Lgraphql/execution/MergedField;",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldType",
+            "desc": "()Lgraphql/schema/GraphQLType;",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSchema",
+            "desc": "()Lgraphql/schema/GraphQLSchema;",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getContext",
+            "desc": "()Ljava/lang/Object;",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getGraphQLContext",
+            "desc": "()Lgraphql/GraphQLContext;",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocalContext",
+            "desc": "()Ljava/lang/Object;",
+            "line": 122,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSelectionSet",
+            "desc": "()Lgraphql/schema/DataFetchingFieldSelectionSet;",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$0",
+            "desc": "(Lgraphql/execution/TypeResolutionParameters;)Lgraphql/collect/ImmutableMapWithNullValues;",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.GraphQLUnusualConfiguration$ResponseMapFactoryConfig": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/GraphQLUnusualConfiguration$GraphQLContextConfiguration;)V",
+            "line": 392,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOr",
+            "desc": "(Lgraphql/execution/ResponseMapFactory;)Lgraphql/execution/ResponseMapFactory;",
+            "line": 400,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setFactory",
+            "desc": "(Lgraphql/execution/ResponseMapFactory;)Lgraphql/GraphQLUnusualConfiguration$ResponseMapFactoryConfig;",
+            "line": 409,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.GraphqlErrorBuilder$GraphqlErrorImpl": {
+        "line": {
+          "covered": 13,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/List;Lgraphql/ErrorClassification;Ljava/util/List;Ljava/util/Map;)V",
+            "line": 157,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMessage",
+            "desc": "()Ljava/lang/String;",
+            "line": 167,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocations",
+            "desc": "()Ljava/util/List;",
+            "line": 172,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/ErrorClassification;",
+            "line": 177,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPath",
+            "desc": "()Ljava/util/List;",
+            "line": 182,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 187,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 192,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.ProfilerResult": {
+        "line": {
+          "covered": 97,
+          "missed": 33
+        },
+        "branch": {
+          "covered": 14,
+          "missed": 12
+        },
+        "method": {
+          "covered": 24,
+          "missed": 13
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 21,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setInstrumentationClasses",
+            "desc": "(Ljava/util/List;)V",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setDataLoaderChainingEnabled",
+            "desc": "(Z)V",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setDataFetcherType",
+            "desc": "(Ljava/lang/String;Lgraphql/ProfilerResult$DataFetcherType;)V",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setDataFetcherResultType",
+            "desc": "(Ljava/lang/String;Lgraphql/ProfilerResult$DataFetcherResultType;)V",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "incrementDataFetcherInvocationCount",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addFieldFetched",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 154,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setExecutionId",
+            "desc": "(Lgraphql/execution/ExecutionId;)V",
+            "line": 158,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setTimes",
+            "desc": "(JJJ)V",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setOperation",
+            "desc": "(Lgraphql/language/OperationDefinition;)V",
+            "line": 168,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addDataLoaderUsed",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 173,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "oldStrategyDispatchingAll",
+            "desc": "(I)V",
+            "line": 177,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "addDispatchEvent",
+            "desc": "(Ljava/lang/String;Ljava/lang/Integer;ILgraphql/ProfilerResult$DispatchEventType;)V",
+            "line": 182,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getOperationName",
+            "desc": "()Ljava/lang/String;",
+            "line": 188,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOperationType",
+            "desc": "()Lgraphql/language/OperationDefinition$Operation;",
+            "line": 192,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldsFetched",
+            "desc": "()Ljava/util/Set;",
+            "line": 196,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCustomDataFetcherFields",
+            "desc": "()Ljava/util/Set;",
+            "line": 200,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 6
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 4
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getTrivialDataFetcherFields",
+            "desc": "()Ljava/util/Set;",
+            "line": 210,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 6
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 4
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getTotalDataFetcherInvocations",
+            "desc": "()I",
+            "line": 221,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTotalTrivialDataFetcherInvocations",
+            "desc": "()I",
+            "line": 225,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTotalCustomDataFetcherInvocations",
+            "desc": "()I",
+            "line": 229,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getStartTime",
+            "desc": "()J",
+            "line": 233,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getEndTime",
+            "desc": "()J",
+            "line": 237,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getEngineTotalRunningTime",
+            "desc": "()J",
+            "line": 241,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTotalExecutionTime",
+            "desc": "()J",
+            "line": 245,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDataFetcherResultType",
+            "desc": "()Ljava/util/Map;",
+            "line": 249,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDataLoaderLoadInvocations",
+            "desc": "()Ljava/util/Map;",
+            "line": 253,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getOldStrategyDispatchingAll",
+            "desc": "()Ljava/util/Set;",
+            "line": 258,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isDataLoaderChainingEnabled",
+            "desc": "()Z",
+            "line": 262,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDispatchEvents",
+            "desc": "()Ljava/util/List;",
+            "line": 266,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getInstrumentationClasses",
+            "desc": "()Ljava/util/List;",
+            "line": 270,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "shortSummaryMap",
+            "desc": "()Ljava/util/Map;",
+            "line": 275,
+            "counters": {
+              "line": {
+                "covered": 42,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createCountMap",
+            "desc": "(II)Ljava/util/LinkedHashMap;",
+            "line": 323,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDispatchEventsAsMap",
+            "desc": "()Ljava/util/List;",
+            "line": 330,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 7
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 344,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$addDataLoaderUsed$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/Integer;)Ljava/lang/Integer;",
+            "line": 173,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$incrementDataFetcherInvocationCount$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/Integer;)Ljava/lang/Integer;",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.TypeMismatchError$GraphQLTypeToTypeKindMapping$1": {
+        "line": {
+          "covered": 10,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.GraphQLError": {
+        "line": {
+          "covered": 5,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "getPath",
+            "desc": "()Ljava/util/List;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toSpecification",
+            "desc": "()Ljava/util/Map;",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fromSpecification",
+            "desc": "(Ljava/util/Map;)Lgraphql/GraphQLError;",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newError",
+            "desc": "()Lgraphql/GraphQLError$Builder;",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.ExecutionInput$Builder": {
+        "line": {
+          "covered": 43,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 18,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 292,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "graphQLContext",
+            "desc": "()Lgraphql/GraphQLContext;",
+            "line": 318,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "query",
+            "desc": "(Ljava/lang/String;)Lgraphql/ExecutionInput$Builder;",
+            "line": 322,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "operationName",
+            "desc": "(Ljava/lang/String;)Lgraphql/ExecutionInput$Builder;",
+            "line": 327,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executionId",
+            "desc": "(Lgraphql/execution/ExecutionId;)Lgraphql/ExecutionInput$Builder;",
+            "line": 339,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "locale",
+            "desc": "(Ljava/util/Locale;)Lgraphql/ExecutionInput$Builder;",
+            "line": 351,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "localContext",
+            "desc": "(Ljava/lang/Object;)Lgraphql/ExecutionInput$Builder;",
+            "line": 363,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "context",
+            "desc": "(Ljava/lang/Object;)Lgraphql/ExecutionInput$Builder;",
+            "line": 378,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "graphQLContext",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/ExecutionInput$Builder;",
+            "line": 391,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "graphQLContext",
+            "desc": "(Ljava/util/Map;)Lgraphql/ExecutionInput$Builder;",
+            "line": 405,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "internalTransferContext",
+            "desc": "(Lgraphql/GraphQLContext;)Lgraphql/ExecutionInput$Builder;",
+            "line": 411,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "internalTransferCancelBoolean",
+            "desc": "(Ljava/util/concurrent/atomic/AtomicBoolean;)Lgraphql/ExecutionInput$Builder;",
+            "line": 417,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "root",
+            "desc": "(Ljava/lang/Object;)Lgraphql/ExecutionInput$Builder;",
+            "line": 423,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "variables",
+            "desc": "(Ljava/util/Map;)Lgraphql/ExecutionInput$Builder;",
+            "line": 435,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "extensions",
+            "desc": "(Ljava/util/Map;)Lgraphql/ExecutionInput$Builder;",
+            "line": 441,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "dataLoaderRegistry",
+            "desc": "(Lorg/dataloader/DataLoaderRegistry;)Lgraphql/ExecutionInput$Builder;",
+            "line": 455,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "profileExecution",
+            "desc": "(Z)Lgraphql/ExecutionInput$Builder;",
+            "line": 460,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/ExecutionInput;",
+            "line": 465,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.GraphqlErrorException": {
+        "line": {
+          "covered": 8,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/GraphqlErrorException$BuilderBase;)V",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocations",
+            "desc": "()Ljava/util/List;",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/ErrorClassification;",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getPath",
+            "desc": "()Ljava/util/List;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newErrorException",
+            "desc": "()Lgraphql/GraphqlErrorException$Builder;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.GraphQL": {
+        "line": {
+          "covered": 127,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 19,
+          "missed": 1
+        },
+        "method": {
+          "covered": 39,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "unusualConfiguration",
+            "desc": "()Lgraphql/GraphQLUnusualConfiguration;",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unusualConfiguration",
+            "desc": "(Lgraphql/ExecutionInput;)Lgraphql/GraphQLUnusualConfiguration$GraphQLContextConfiguration;",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unusualConfiguration",
+            "desc": "(Lgraphql/ExecutionInput$Builder;)Lgraphql/GraphQLUnusualConfiguration$GraphQLContextConfiguration;",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unusualConfiguration",
+            "desc": "(Lgraphql/GraphQLContext;)Lgraphql/GraphQLUnusualConfiguration$GraphQLContextConfiguration;",
+            "line": 143,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unusualConfiguration",
+            "desc": "(Lgraphql/GraphQLContext$Builder;)Lgraphql/GraphQLUnusualConfiguration$GraphQLContextConfiguration;",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/GraphQL$Builder;)V",
+            "line": 170,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getGraphQLSchema",
+            "desc": "()Lgraphql/schema/GraphQLSchema;",
+            "line": 186,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getQueryStrategy",
+            "desc": "()Lgraphql/execution/ExecutionStrategy;",
+            "line": 193,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMutationStrategy",
+            "desc": "()Lgraphql/execution/ExecutionStrategy;",
+            "line": 200,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSubscriptionStrategy",
+            "desc": "()Lgraphql/execution/ExecutionStrategy;",
+            "line": 207,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getIdProvider",
+            "desc": "()Lgraphql/execution/ExecutionIdProvider;",
+            "line": 214,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInstrumentation",
+            "desc": "()Lgraphql/execution/instrumentation/Instrumentation;",
+            "line": 221,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isDoNotAutomaticallyDispatchDataLoader",
+            "desc": "()Z",
+            "line": 225,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getPreparsedDocumentProvider",
+            "desc": "()Lgraphql/execution/preparsed/PreparsedDocumentProvider;",
+            "line": 232,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getValueUnboxer",
+            "desc": "()Lgraphql/execution/ValueUnboxer;",
+            "line": 239,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newGraphQL",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Lgraphql/GraphQL$Builder;",
+            "line": 250,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/GraphQL;",
+            "line": 262,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "execute",
+            "desc": "(Ljava/lang/String;)Lgraphql/ExecutionResult;",
+            "line": 386,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "execute",
+            "desc": "(Lgraphql/ExecutionInput$Builder;)Lgraphql/ExecutionResult;",
+            "line": 401,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "execute",
+            "desc": "(Ljava/util/function/UnaryOperator;)Lgraphql/ExecutionResult;",
+            "line": 419,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "execute",
+            "desc": "(Lgraphql/ExecutionInput;)Lgraphql/ExecutionResult;",
+            "line": 431,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executeAsync",
+            "desc": "(Lgraphql/ExecutionInput$Builder;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 452,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executeAsync",
+            "desc": "(Ljava/util/function/UnaryOperator;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 473,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executeAsync",
+            "desc": "(Lgraphql/ExecutionInput;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 487,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleAbortException",
+            "desc": "(Lgraphql/ExecutionInput;Lgraphql/execution/instrumentation/InstrumentationState;Lgraphql/execution/AbortExecutionException;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 525,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ensureInputHasId",
+            "desc": "(Lgraphql/ExecutionInput;)Lgraphql/ExecutionInput;",
+            "line": 530,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseValidateAndExecute",
+            "desc": "(Lgraphql/ExecutionInput;Lgraphql/schema/GraphQLSchema;Lgraphql/execution/instrumentation/InstrumentationState;Lgraphql/EngineRunningState;Lgraphql/Profiler;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 541,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseAndValidate",
+            "desc": "(Ljava/util/concurrent/atomic/AtomicReference;Lgraphql/schema/GraphQLSchema;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/preparsed/PreparsedDocumentEntry;",
+            "line": 562,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parse",
+            "desc": "(Lgraphql/ExecutionInput;Lgraphql/schema/GraphQLSchema;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/ParseAndValidateResult;",
+            "line": 588,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validate",
+            "desc": "(Lgraphql/ExecutionInput;Lgraphql/language/Document;Lgraphql/schema/GraphQLSchema;Lgraphql/execution/instrumentation/InstrumentationState;)Ljava/util/List;",
+            "line": 607,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "execute",
+            "desc": "(Lgraphql/ExecutionInput;Lgraphql/language/Document;Lgraphql/schema/GraphQLSchema;Lgraphql/execution/instrumentation/InstrumentationState;Lgraphql/EngineRunningState;Lgraphql/Profiler;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 634,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$validate$1",
+            "desc": "(Ljava/util/function/Predicate;Lgraphql/validation/OperationValidationRule;)Z",
+            "line": 617,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$validate$0",
+            "desc": "(Lgraphql/validation/OperationValidationRule;)Z",
+            "line": 610,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$parseAndValidate$0",
+            "desc": "(Lgraphql/ParseAndValidateResult;Lgraphql/ExecutionInput$Builder;)V",
+            "line": 570,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$parseValidateAndExecute$1",
+            "desc": "(Ljava/util/concurrent/atomic/AtomicReference;Lgraphql/schema/GraphQLSchema;Lgraphql/execution/instrumentation/InstrumentationState;Lgraphql/EngineRunningState;Lgraphql/Profiler;Lgraphql/execution/preparsed/PreparsedDocumentEntry;)Ljava/util/concurrent/CompletionStage;",
+            "line": 549,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$parseValidateAndExecute$0",
+            "desc": "(Ljava/util/concurrent/atomic/AtomicReference;Lgraphql/schema/GraphQLSchema;Lgraphql/execution/instrumentation/InstrumentationState;Lgraphql/ExecutionInput;)Lgraphql/execution/preparsed/PreparsedDocumentEntry;",
+            "line": 544,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$ensureInputHasId$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/Object;Lgraphql/ExecutionInput$Builder;)V",
+            "line": 536,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$executeAsync$0",
+            "desc": "(Lgraphql/ExecutionInput;Lgraphql/Profiler;Lgraphql/EngineRunningState;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 490,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$executeAsync$1",
+            "desc": "(Lgraphql/ExecutionInput;Lgraphql/EngineRunningState;Lgraphql/Profiler;Lgraphql/ExecutionInput;Lgraphql/execution/instrumentation/InstrumentationState;)Ljava/util/concurrent/CompletionStage;",
+            "line": 499,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$executeAsync$2",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/InstrumentationState;Lgraphql/ExecutionResult;)Ljava/util/concurrent/CompletionStage;",
+            "line": 514,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.GraphqlErrorHelper": {
+        "line": {
+          "covered": 80,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 39,
+          "missed": 11
+        },
+        "method": {
+          "covered": 10,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 21,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toSpecification",
+            "desc": "(Lgraphql/GraphQLError;)Ljava/util/Map;",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "locations",
+            "desc": "(Ljava/util/List;)Ljava/lang/Object;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "location",
+            "desc": "(Lgraphql/language/SourceLocation;)Ljava/lang/Object;",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fromSpecification",
+            "desc": "(Ljava/util/List;)Ljava/util/List;",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fromSpecification",
+            "desc": "(Ljava/util/Map;)Lgraphql/GraphQLError;",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "extractPath",
+            "desc": "(Lgraphql/GraphQLError$Builder;Ljava/util/Map;)V",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "extractExtensions",
+            "desc": "(Lgraphql/GraphQLError$Builder;Ljava/util/Map;)V",
+            "line": 109,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "extractLocations",
+            "desc": "(Lgraphql/GraphQLError$Builder;Ljava/util/Map;)V",
+            "line": 122,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hashCode",
+            "desc": "(Lgraphql/GraphQLError;)I",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "equals",
+            "desc": "(Lgraphql/GraphQLError;Ljava/lang/Object;)Z",
+            "line": 149,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 4
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.GraphQLUnusualConfiguration$GraphQLContextConfiguration": {
+        "line": {
+          "covered": 21,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 6,
+          "missed": 0
+        },
+        "method": {
+          "covered": 8,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/GraphQLContext;)V",
+            "line": 248,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/GraphQLContext$Builder;)V",
+            "line": 253,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "incrementalSupport",
+            "desc": "()Lgraphql/GraphQLUnusualConfiguration$IncrementalSupportConfig;",
+            "line": 262,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "dataloaderConfig",
+            "desc": "()Lgraphql/GraphQLUnusualConfiguration$DataloaderConfig;",
+            "line": 270,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "responseMapFactory",
+            "desc": "()Lgraphql/GraphQLUnusualConfiguration$ResponseMapFactoryConfig;",
+            "line": 277,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "put",
+            "desc": "(Ljava/lang/String;Ljava/lang/Object;)V",
+            "line": 281,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getBoolean",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 289,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "get",
+            "desc": "(Ljava/lang/String;)Ljava/lang/Object;",
+            "line": 297,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.ParseAndValidateResult$Builder": {
+        "line": {
+          "covered": 12,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "document",
+            "desc": "(Lgraphql/language/Document;)Lgraphql/ParseAndValidateResult$Builder;",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "variables",
+            "desc": "(Ljava/util/Map;)Lgraphql/ParseAndValidateResult$Builder;",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validationErrors",
+            "desc": "(Ljava/util/List;)Lgraphql/ParseAndValidateResult$Builder;",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "syntaxException",
+            "desc": "(Lgraphql/parser/InvalidSyntaxException;)Lgraphql/ParseAndValidateResult$Builder;",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/ParseAndValidateResult;",
+            "line": 135,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.ErrorClassification": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "toSpecification",
+            "desc": "(Lgraphql/GraphQLError;)Ljava/lang/Object;",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "errorClassification",
+            "desc": "(Ljava/lang/String;)Lgraphql/ErrorClassification;",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.Scalars": {
+        "line": {
+          "covered": 10,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.ErrorClassification$1": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.ExecutionResult": {
+        "line": {
+          "covered": 5,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "fromSpecification",
+            "desc": "(Ljava/util/Map;)Lgraphql/ExecutionResult;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/ExecutionResult;",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newExecutionResult",
+            "desc": "()Lgraphql/ExecutionResult$Builder;",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.GraphQL$Builder": {
+        "line": {
+          "covered": 32,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 8,
+          "missed": 0
+        },
+        "method": {
+          "covered": 9,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)V",
+            "line": 283,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "schema",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Lgraphql/GraphQL$Builder;",
+            "line": 295,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "queryExecutionStrategy",
+            "desc": "(Lgraphql/execution/ExecutionStrategy;)Lgraphql/GraphQL$Builder;",
+            "line": 300,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mutationExecutionStrategy",
+            "desc": "(Lgraphql/execution/ExecutionStrategy;)Lgraphql/GraphQL$Builder;",
+            "line": 305,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "subscriptionExecutionStrategy",
+            "desc": "(Lgraphql/execution/ExecutionStrategy;)Lgraphql/GraphQL$Builder;",
+            "line": 310,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "defaultDataFetcherExceptionHandler",
+            "desc": "(Lgraphql/execution/DataFetcherExceptionHandler;)Lgraphql/GraphQL$Builder;",
+            "line": 323,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "instrumentation",
+            "desc": "(Lgraphql/execution/instrumentation/Instrumentation;)Lgraphql/GraphQL$Builder;",
+            "line": 328,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "preparsedDocumentProvider",
+            "desc": "(Lgraphql/execution/preparsed/PreparsedDocumentProvider;)Lgraphql/GraphQL$Builder;",
+            "line": 333,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executionIdProvider",
+            "desc": "(Lgraphql/execution/ExecutionIdProvider;)Lgraphql/GraphQL$Builder;",
+            "line": 338,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "doNotAutomaticallyDispatchDataLoader",
+            "desc": "()Lgraphql/GraphQL$Builder;",
+            "line": 350,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "valueUnboxer",
+            "desc": "(Lgraphql/execution/ValueUnboxer;)Lgraphql/GraphQL$Builder;",
+            "line": 355,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/GraphQL;",
+            "line": 361,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.GraphQLException": {
+        "line": {
+          "covered": 8,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 7,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 11,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/Throwable;)V",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Throwable;)V",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.ExecutionResultImpl": {
+        "line": {
+          "covered": 44,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 15,
+          "missed": 1
+        },
+        "method": {
+          "covered": 15,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/GraphQLError;)V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;)V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Object;Ljava/util/List;)V",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Object;Ljava/util/List;Ljava/util/Map;)V",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/ExecutionResultImpl;)V",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/ExecutionResultImpl$Builder;)V",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(ZLjava/lang/Object;Ljava/util/List;Ljava/util/Map;)V",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isDataPresent",
+            "desc": "()Z",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrors",
+            "desc": "()Ljava/util/List;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getData",
+            "desc": "()Ljava/lang/Object;",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toSpecification",
+            "desc": "()Ljava/util/Map;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "errorsToSpec",
+            "desc": "(Ljava/util/List;)Ljava/lang/Object;",
+            "line": 97,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fromSpecification",
+            "desc": "(Ljava/util/Map;)Lgraphql/ExecutionResult;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newExecutionResult",
+            "desc": "()Lgraphql/ExecutionResultImpl$Builder;",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.ProfilerResult$DispatchEventType": {
+        "line": {
+          "covered": 0,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 0,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 6
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.ExecutionInput": {
+        "line": {
+          "covered": 55,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 11,
+          "missed": 1
+        },
+        "method": {
+          "covered": 23,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/ExecutionInput$Builder;)V",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertQuery",
+            "desc": "(Lgraphql/ExecutionInput$Builder;)Ljava/lang/String;",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isPersistedQuery",
+            "desc": "(Lgraphql/ExecutionInput$Builder;)Z",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getQuery",
+            "desc": "()Ljava/lang/String;",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOperationName",
+            "desc": "()Ljava/lang/String;",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getContext",
+            "desc": "()Ljava/lang/Object;",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getGraphQLContext",
+            "desc": "()Lgraphql/GraphQLContext;",
+            "line": 124,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocalContext",
+            "desc": "()Ljava/lang/Object;",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getRoot",
+            "desc": "()Ljava/lang/Object;",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getVariables",
+            "desc": "()Ljava/util/Map;",
+            "line": 147,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getRawVariables",
+            "desc": "()Lgraphql/execution/RawVariables;",
+            "line": 154,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDataLoaderRegistry",
+            "desc": "()Lorg/dataloader/DataLoaderRegistry;",
+            "line": 161,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExecutionId",
+            "desc": "()Lgraphql/execution/ExecutionId;",
+            "line": 173,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExecutionIdNonNull",
+            "desc": "()Lgraphql/execution/ExecutionId;",
+            "line": 184,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocale",
+            "desc": "()Ljava/util/Locale;",
+            "line": 193,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 200,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isCancelled",
+            "desc": "()Z",
+            "line": 214,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "cancel",
+            "desc": "()V",
+            "line": 222,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isProfileExecution",
+            "desc": "()Z",
+            "line": 227,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/ExecutionInput;",
+            "line": 239,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 260,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newExecutionInput",
+            "desc": "()Lgraphql/ExecutionInput$Builder;",
+            "line": 277,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newExecutionInput",
+            "desc": "(Ljava/lang/String;)Lgraphql/ExecutionInput$Builder;",
+            "line": 288,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.ParseAndValidate": {
+        "line": {
+          "covered": 22,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 9,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "parseAndValidate",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/ExecutionInput;)Lgraphql/ParseAndValidateResult;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parse",
+            "desc": "(Lgraphql/ExecutionInput;)Lgraphql/ParseAndValidateResult;",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validate",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/Document;Ljava/util/Locale;)Ljava/util/List;",
+            "line": 97,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validate",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/Document;)Ljava/util/List;",
+            "line": 109,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validate",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/Document;Ljava/util/function/Predicate;Ljava/util/Locale;)Ljava/util/List;",
+            "line": 123,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validate",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/Document;Ljava/util/function/Predicate;Ljava/util/Locale;Lgraphql/validation/QueryComplexityLimits;)Ljava/util/List;",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validate",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/Document;Ljava/util/function/Predicate;)Ljava/util/List;",
+            "line": 152,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$validate$1",
+            "desc": "(Lgraphql/validation/OperationValidationRule;)Z",
+            "line": 109,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$validate$0",
+            "desc": "(Lgraphql/validation/OperationValidationRule;)Z",
+            "line": 97,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$parseAndValidate$0",
+            "desc": "(Ljava/util/List;Lgraphql/ParseAndValidateResult$Builder;)V",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.AssertException": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 11,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.ProfilerResult$DispatchEvent": {
+        "line": {
+          "covered": 0,
+          "missed": 11
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 0,
+          "missed": 6
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/Integer;ILgraphql/ProfilerResult$DispatchEventType;)V",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 6
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDataLoaderName",
+            "desc": "()Ljava/lang/String;",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getLevel",
+            "desc": "()Ljava/lang/Integer;",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getKeyCount",
+            "desc": "()I",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getType",
+            "desc": "()Lgraphql/ProfilerResult$DispatchEventType;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.ProfilerImpl$1": {
+        "line": {
+          "covered": 4,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 1,
+          "missed": 1
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/ProfilerImpl;Lgraphql/execution/EngineRunningObserver;)V",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "runningStateChanged",
+            "desc": "(Lgraphql/execution/ExecutionId;Lgraphql/GraphQLContext;Lgraphql/execution/EngineRunningObserver$RunningState;)V",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.TypeMismatchError$GraphQLTypeToTypeKindMapping": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 1,
+          "missed": 1
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "getTypeKindFromGraphQLType",
+            "desc": "(Lgraphql/schema/GraphQLType;)Lgraphql/introspection/Introspection$TypeKind;",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.GraphQLUnusualConfiguration$ParserConfig": {
+        "line": {
+          "covered": 5,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/GraphQLUnusualConfiguration;)V",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefaultParserOptions",
+            "desc": "()Lgraphql/parser/ParserOptions;",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setDefaultParserOptions",
+            "desc": "(Lgraphql/parser/ParserOptions;)Lgraphql/GraphQLUnusualConfiguration$ParserConfig;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefaultOperationParserOptions",
+            "desc": "()Lgraphql/parser/ParserOptions;",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "setDefaultOperationParserOptions",
+            "desc": "(Lgraphql/parser/ParserOptions;)Lgraphql/GraphQLUnusualConfiguration$ParserConfig;",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDefaultSdlParserOptions",
+            "desc": "()Lgraphql/parser/ParserOptions;",
+            "line": 148,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "setDefaultSdlParserOptions",
+            "desc": "(Lgraphql/parser/ParserOptions;)Lgraphql/GraphQLUnusualConfiguration$ParserConfig;",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.ProfilerResult$DataFetcherResultType": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.GraphqlErrorBuilder": {
+        "line": {
+          "covered": 38,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 8,
+          "missed": 2
+        },
+        "method": {
+          "covered": 16,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "getMessage",
+            "desc": "()Ljava/lang/String;",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPath",
+            "desc": "()Ljava/util/List;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocations",
+            "desc": "()Ljava/util/List;",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/ErrorClassification;",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "newError",
+            "desc": "()Lgraphql/GraphqlErrorBuilder;",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newError",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Lgraphql/GraphqlErrorBuilder;",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "message",
+            "desc": "(Ljava/lang/String;[Ljava/lang/Object;)Lgraphql/GraphqlErrorBuilder;",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "locations",
+            "desc": "(Ljava/util/List;)Lgraphql/GraphqlErrorBuilder;",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "location",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/GraphqlErrorBuilder;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "path",
+            "desc": "(Lgraphql/execution/ResultPath;)Lgraphql/GraphqlErrorBuilder;",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "path",
+            "desc": "(Ljava/util/List;)Lgraphql/GraphqlErrorBuilder;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "errorType",
+            "desc": "(Lgraphql/ErrorClassification;)Lgraphql/GraphqlErrorBuilder;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "extensions",
+            "desc": "(Ljava/util/Map;)Lgraphql/GraphqlErrorBuilder;",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/GraphQLError;",
+            "line": 134,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toResult",
+            "desc": "()Lgraphql/execution/DataFetcherResult;",
+            "line": 224,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.GraphQLUnusualConfiguration$DataloaderConfig": {
+        "line": {
+          "covered": 5,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/GraphQLUnusualConfiguration$GraphQLContextConfiguration;)V",
+            "line": 354,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isDataLoaderChainingEnabled",
+            "desc": "()Z",
+            "line": 361,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isDataLoaderExhaustedDispatchingEnabled",
+            "desc": "()Z",
+            "line": 365,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "enableDataLoaderChaining",
+            "desc": "(Z)Lgraphql/GraphQLUnusualConfiguration$DataloaderConfig;",
+            "line": 373,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enableDataLoaderExhaustedDispatching",
+            "desc": "(Z)Lgraphql/GraphQLUnusualConfiguration$DataloaderConfig;",
+            "line": 383,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.Directives": {
+        "line": {
+          "covered": 172,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isBuiltInDirective",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 296,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isBuiltInDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)Z",
+            "line": 307,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createDescription",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/Description;",
+            "line": 311,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isExperimentalDisableErrorPropagationDirectiveEnabled",
+            "desc": "()Z",
+            "line": 321,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setExperimentalDisableErrorPropagationEnabled",
+            "desc": "(Z)V",
+            "line": 331,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 166,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.ExecutionResultImpl$Builder": {
+        "line": {
+          "covered": 22,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 9,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "from",
+            "desc": "(Lgraphql/ExecutionResult;)Lgraphql/ExecutionResultImpl$Builder;",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "data",
+            "desc": "(Ljava/lang/Object;)Lgraphql/ExecutionResultImpl$Builder;",
+            "line": 149,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "errors",
+            "desc": "(Ljava/util/List;)Lgraphql/ExecutionResultImpl$Builder;",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addErrors",
+            "desc": "(Ljava/util/List;)Lgraphql/ExecutionResultImpl$Builder;",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addError",
+            "desc": "(Lgraphql/GraphQLError;)Lgraphql/ExecutionResultImpl$Builder;",
+            "line": 168,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "extensions",
+            "desc": "(Ljava/util/Map;)Lgraphql/ExecutionResultImpl$Builder;",
+            "line": 174,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addExtension",
+            "desc": "(Ljava/lang/String;Ljava/lang/Object;)Lgraphql/ExecutionResultImpl$Builder;",
+            "line": 180,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/ExecutionResult;",
+            "line": 187,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.GraphqlErrorException$BuilderBase": {
+        "line": {
+          "covered": 12,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "asDerivedType",
+            "desc": "()Lgraphql/GraphqlErrorException$BuilderBase;",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "message",
+            "desc": "(Ljava/lang/String;)Lgraphql/GraphqlErrorException$BuilderBase;",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "cause",
+            "desc": "(Ljava/lang/Throwable;)Lgraphql/GraphqlErrorException$BuilderBase;",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/GraphqlErrorException$BuilderBase;",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocations",
+            "desc": "(Ljava/util/List;)Lgraphql/GraphqlErrorException$BuilderBase;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "errorClassification",
+            "desc": "(Lgraphql/ErrorClassification;)Lgraphql/GraphqlErrorException$BuilderBase;",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "path",
+            "desc": "(Ljava/util/List;)Lgraphql/GraphqlErrorException$BuilderBase;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "extensions",
+            "desc": "(Ljava/util/Map;)Lgraphql/GraphqlErrorException$BuilderBase;",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.GraphQLContext": {
+        "line": {
+          "covered": 42,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 24,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/concurrent/ConcurrentMap;)V",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "delete",
+            "desc": "(Ljava/lang/Object;)Lgraphql/GraphQLContext;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "get",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOrDefault",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOrEmpty",
+            "desc": "(Ljava/lang/Object;)Ljava/util/Optional;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getBoolean",
+            "desc": "(Ljava/lang/Object;)Z",
+            "line": 113,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getBoolean",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Boolean;)Z",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasKey",
+            "desc": "(Ljava/lang/Object;)Z",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "put",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;)Lgraphql/GraphQLContext;",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "putAll",
+            "desc": "(Ljava/util/Map;)Lgraphql/GraphQLContext;",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "putAll",
+            "desc": "(Lgraphql/GraphQLContext;)Lgraphql/GraphQLContext;",
+            "line": 178,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "putAll",
+            "desc": "(Lgraphql/GraphQLContext$Builder;)Lgraphql/GraphQLContext;",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "putAll",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/GraphQLContext;",
+            "line": 202,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "compute",
+            "desc": "(Ljava/lang/Object;Ljava/util/function/BiFunction;)Ljava/lang/Object;",
+            "line": 219,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "computeIfAbsent",
+            "desc": "(Ljava/lang/Object;Ljava/util/function/Function;)Ljava/lang/Object;",
+            "line": 235,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "computeIfPresent",
+            "desc": "(Ljava/lang/Object;Ljava/util/function/BiFunction;)Ljava/lang/Object;",
+            "line": 250,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "stream",
+            "desc": "()Ljava/util/stream/Stream;",
+            "line": 258,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 280,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Ljava/util/Map;)Lgraphql/GraphQLContext;",
+            "line": 291,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/GraphQLContext;",
+            "line": 302,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefault",
+            "desc": "()Lgraphql/GraphQLContext;",
+            "line": 311,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newContext",
+            "desc": "()Lgraphql/GraphQLContext$Builder;",
+            "line": 320,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$computeIfPresent$0",
+            "desc": "(Ljava/util/function/BiFunction;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 251,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$compute$0",
+            "desc": "(Ljava/util/function/BiFunction;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 220,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.ProfilerResult$DataFetcherType": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.ExceptionWhileDataFetching": {
+        "line": {
+          "covered": 21,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 10,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/ResultPath;Ljava/lang/Throwable;Lgraphql/language/SourceLocation;)V",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkMessage",
+            "desc": "(Lgraphql/execution/ResultPath;Ljava/lang/Throwable;)Ljava/lang/String;",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkExtensions",
+            "desc": "(Ljava/lang/Throwable;)Ljava/util/Map;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getException",
+            "desc": "()Ljava/lang/Throwable;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMessage",
+            "desc": "()Ljava/lang/String;",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocations",
+            "desc": "()Ljava/util/List;",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPath",
+            "desc": "()Ljava/util/List;",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/ErrorType;",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.GraphQLUnusualConfiguration$BaseConfig": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/GraphQLUnusualConfiguration;)V",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "then",
+            "desc": "()Lgraphql/GraphQLUnusualConfiguration;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.SerializationError": {
+        "line": {
+          "covered": 11,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/ResultPath;Lgraphql/schema/CoercingSerializeException;)V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkMessage",
+            "desc": "(Lgraphql/execution/ResultPath;Lgraphql/schema/CoercingSerializeException;)Ljava/lang/String;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getException",
+            "desc": "()Lgraphql/schema/CoercingSerializeException;",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getMessage",
+            "desc": "()Ljava/lang/String;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocations",
+            "desc": "()Ljava/util/List;",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/ErrorType;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPath",
+            "desc": "()Ljava/util/List;",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.DirectivesUtil$DirectivesHolder": {
+        "line": {
+          "covered": 29,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 11,
+          "missed": 1
+        },
+        "method": {
+          "covered": 13,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Collection;Ljava/util/Collection;)V",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "create",
+            "desc": "(Ljava/util/List;Ljava/util/List;)Lgraphql/DirectivesUtil$DirectivesHolder;",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllDirectivesByName",
+            "desc": "()Lcom/google/common/collect/ImmutableMap;",
+            "line": 159,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Lcom/google/common/collect/ImmutableMap;",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 167,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLDirective;",
+            "line": 171,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 179,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getAllAppliedDirectivesByName",
+            "desc": "()Lcom/google/common/collect/ImmutableMap;",
+            "line": 183,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 187,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirectives",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 191,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLAppliedDirective;",
+            "line": 195,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 201,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$0",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)Z",
+            "line": 143,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.Profiler$1": {
+        "line": {
+          "covered": 1,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 18,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.ErrorType": {
+        "line": {
+          "covered": 7,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 9,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.GraphQLUnusualConfiguration": {
+        "line": {
+          "covered": 5,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parsing",
+            "desc": "()Lgraphql/GraphQLUnusualConfiguration$ParserConfig;",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "propertyDataFetching",
+            "desc": "()Lgraphql/GraphQLUnusualConfiguration$PropertyDataFetcherConfig;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "goodFaithIntrospection",
+            "desc": "()Lgraphql/GraphQLUnusualConfiguration$GoodFaithIntrospectionConfig;",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.GraphQLUnusualConfiguration$BaseContextConfig": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/GraphQLUnusualConfiguration$GraphQLContextConfiguration;)V",
+            "line": 309,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "then",
+            "desc": "()Lgraphql/GraphQLUnusualConfiguration$GraphQLContextConfiguration;",
+            "line": 317,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.GraphQLUnusualConfiguration$PropertyDataFetcherConfig": {
+        "line": {
+          "covered": 3,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/GraphQLUnusualConfiguration;)V",
+            "line": 170,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clearReflectionCache",
+            "desc": "()Lgraphql/GraphQLUnusualConfiguration$PropertyDataFetcherConfig;",
+            "line": 183,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "setUseSetAccessible",
+            "desc": "(Z)Z",
+            "line": 196,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "setUseNegativeCache",
+            "desc": "(Z)Z",
+            "line": 207,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.GraphqlErrorException$Builder": {
+        "line": {
+          "covered": 0,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 0,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/GraphqlErrorException;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.Profiler": {
+        "line": {
+          "covered": 6,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "setExecutionInputAndInstrumentation",
+            "desc": "(Lgraphql/ExecutionInput;Lgraphql/execution/instrumentation/Instrumentation;)V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "dataLoaderUsed",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "fieldFetched",
+            "desc": "(Ljava/lang/Object;Lgraphql/schema/DataFetcher;Lgraphql/schema/DataFetcher;Lgraphql/execution/ResultPath;Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/GraphQLOutputType;)V",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "wrapEngineRunningObserver",
+            "desc": "(Lgraphql/execution/EngineRunningObserver;)Lgraphql/execution/EngineRunningObserver;",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "operationDefinition",
+            "desc": "(Lgraphql/language/OperationDefinition;)V",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "oldStrategyDispatchingAll",
+            "desc": "(I)V",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "batchLoadedOldStrategy",
+            "desc": "(Ljava/lang/String;II)V",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "batchLoadedNewStrategy",
+            "desc": "(Ljava/lang/String;Ljava/lang/Integer;IZZ)V",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "manualDispatch",
+            "desc": "(Ljava/lang/String;II)V",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 18,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.GraphQLUnusualConfiguration$IncrementalSupportConfig": {
+        "line": {
+          "covered": 5,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/GraphQLUnusualConfiguration$GraphQLContextConfiguration;)V",
+            "line": 323,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isIncrementalSupportEnabled",
+            "desc": "()Z",
+            "line": 330,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enableIncrementalSupport",
+            "desc": "(Z)Lgraphql/GraphQLUnusualConfiguration$IncrementalSupportConfig;",
+            "line": 338,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enableEarlyIncrementalFieldExecution",
+            "desc": "(Z)Lgraphql/GraphQLUnusualConfiguration$IncrementalSupportConfig;",
+            "line": 347,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.Assert": {
+        "line": {
+          "covered": 57,
+          "missed": 54
+        },
+        "branch": {
+          "covered": 59,
+          "missed": 31
+        },
+        "method": {
+          "covered": 25,
+          "missed": 8
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 14,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "assertNotNullWithNPE",
+            "desc": "(Ljava/lang/Object;Ljava/util/function/Supplier;)Ljava/lang/Object;",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "assertNotNullWithNPE",
+            "desc": "(Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertNotNull",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertNotNull",
+            "desc": "(Ljava/lang/Object;Ljava/util/function/Supplier;)Ljava/lang/Object;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertNotNull",
+            "desc": "(Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertNotNull",
+            "desc": "(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertNotNull",
+            "desc": "(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertNotNull",
+            "desc": "(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertNull",
+            "desc": "(Ljava/lang/Object;Ljava/util/function/Supplier;)V",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "assertNull",
+            "desc": "(Ljava/lang/Object;Ljava/lang/String;)V",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertNull",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 97,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "assertNeverCalled",
+            "desc": "()Ljava/lang/Object;",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "assertShouldNeverHappen",
+            "desc": "(Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "assertShouldNeverHappen",
+            "desc": "()Ljava/lang/Object;",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "assertNotEmpty",
+            "desc": "(Ljava/util/Collection;)Ljava/util/Collection;",
+            "line": 119,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertNotEmpty",
+            "desc": "(Ljava/util/Collection;Ljava/util/function/Supplier;)Ljava/util/Collection;",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertNotEmpty",
+            "desc": "(Ljava/util/Collection;Ljava/lang/String;)Ljava/util/Collection;",
+            "line": 134,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertTrue",
+            "desc": "(ZLjava/util/function/Supplier;)V",
+            "line": 141,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertTrue",
+            "desc": "(Z)V",
+            "line": 148,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertTrue",
+            "desc": "(ZLjava/lang/String;)V",
+            "line": 155,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertTrue",
+            "desc": "(ZLjava/lang/String;Ljava/lang/Object;)V",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertTrue",
+            "desc": "(ZLjava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)V",
+            "line": 169,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertTrue",
+            "desc": "(ZLjava/lang/String;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)V",
+            "line": 176,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertFalse",
+            "desc": "(ZLjava/util/function/Supplier;)V",
+            "line": 183,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "assertFalse",
+            "desc": "(Z)V",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertFalse",
+            "desc": "(ZLjava/lang/String;)V",
+            "line": 197,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertFalse",
+            "desc": "(ZLjava/lang/String;Ljava/lang/Object;)V",
+            "line": 204,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertFalse",
+            "desc": "(ZLjava/lang/String;Ljava/lang/Object;Ljava/lang/Object;)V",
+            "line": 211,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertFalse",
+            "desc": "(ZLjava/lang/String;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)V",
+            "line": 218,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertValidName",
+            "desc": "(Ljava/lang/String;)Ljava/lang/String;",
+            "line": 235,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isValidName",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 246,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 27,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "throwAssert",
+            "desc": "(Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 268,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.values.ValueVisitor": {
+        "line": {
+          "covered": 6,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "visitScalarValue",
+            "desc": "(Ljava/lang/Object;Lgraphql/schema/GraphQLScalarType;Lgraphql/analysis/values/ValueVisitor$InputElements;)Ljava/lang/Object;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitEnumValue",
+            "desc": "(Ljava/lang/Object;Lgraphql/schema/GraphQLEnumType;Lgraphql/analysis/values/ValueVisitor$InputElements;)Ljava/lang/Object;",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "visitInputObjectFieldValue",
+            "desc": "(Ljava/lang/Object;Lgraphql/schema/GraphQLInputObjectType;Lgraphql/schema/GraphQLInputObjectField;Lgraphql/analysis/values/ValueVisitor$InputElements;)Ljava/lang/Object;",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitInputObjectValue",
+            "desc": "(Ljava/util/Map;Lgraphql/schema/GraphQLInputObjectType;Lgraphql/analysis/values/ValueVisitor$InputElements;)Ljava/util/Map;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitListValue",
+            "desc": "(Ljava/util/List;Lgraphql/schema/GraphQLList;Lgraphql/analysis/values/ValueVisitor$InputElements;)Ljava/util/List;",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitArgumentValue",
+            "desc": "(Ljava/lang/Object;Lgraphql/schema/GraphQLArgument;Lgraphql/analysis/values/ValueVisitor$InputElements;)Ljava/lang/Object;",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitAppliedDirectiveArgumentValue",
+            "desc": "(Ljava/lang/Object;Lgraphql/schema/GraphQLAppliedDirectiveArgument;Lgraphql/analysis/values/ValueVisitor$InputElements;)Ljava/lang/Object;",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.values.ValueVisitor$1": {
+        "line": {
+          "covered": 1,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.values.ValueTraverser": {
+        "line": {
+          "covered": 111,
+          "missed": 8
+        },
+        "branch": {
+          "covered": 71,
+          "missed": 7
+        },
+        "method": {
+          "covered": 9,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "visitPreOrder",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;Lgraphql/analysis/values/ValueVisitor;)Lgraphql/schema/DataFetchingEnvironment;",
+            "line": 109,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitPreOrder",
+            "desc": "(Ljava/util/Map;Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/analysis/values/ValueVisitor;)Ljava/util/Map;",
+            "line": 128,
+            "counters": {
+              "line": {
+                "covered": 21,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 12,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitPreOrder",
+            "desc": "(Ljava/lang/Object;Lgraphql/schema/GraphQLArgument;Lgraphql/analysis/values/ValueVisitor;)Ljava/lang/Object;",
+            "line": 169,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitPreOrder",
+            "desc": "(Ljava/lang/Object;Lgraphql/schema/GraphQLAppliedDirectiveArgument;Lgraphql/analysis/values/ValueVisitor;)Ljava/lang/Object;",
+            "line": 193,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitPreOrderImpl",
+            "desc": "(Ljava/lang/Object;Lgraphql/schema/GraphQLInputType;Lgraphql/analysis/values/ValueTraverser$InputElements;Lgraphql/analysis/values/ValueVisitor;)Ljava/lang/Object;",
+            "line": 206,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 9,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitObjectValue",
+            "desc": "(Ljava/lang/Object;Lgraphql/schema/GraphQLInputObjectType;Lgraphql/analysis/values/ValueTraverser$InputElements;Lgraphql/analysis/values/ValueVisitor;)Ljava/lang/Object;",
+            "line": 226,
+            "counters": {
+              "line": {
+                "covered": 28,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 18,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitListValue",
+            "desc": "(Ljava/lang/Object;Lgraphql/schema/GraphQLList;Lgraphql/analysis/values/ValueTraverser$InputElements;Lgraphql/analysis/values/ValueVisitor;)Ljava/lang/Object;",
+            "line": 271,
+            "counters": {
+              "line": {
+                "covered": 26,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 19,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasChanged",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;)Z",
+            "line": 314,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setNewValue",
+            "desc": "(Ljava/util/Map;Ljava/lang/String;Ljava/lang/Object;)V",
+            "line": 318,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.values.ValueTraverser$InputElements": {
+        "line": {
+          "covered": 20,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 8,
+          "missed": 0
+        },
+        "method": {
+          "covered": 8,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLInputSchemaElement;)V",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lcom/google/common/collect/ImmutableList;)V",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "push",
+            "desc": "(Lgraphql/schema/GraphQLInputSchemaElement;)Lgraphql/analysis/values/ValueTraverser$InputElements;",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInputElements",
+            "desc": "()Ljava/util/List;",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getUnwrappedInputElements",
+            "desc": "()Ljava/util/List;",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLastInputValueDefinition",
+            "desc": "()Lgraphql/schema/GraphQLInputValueDefinition;",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$1",
+            "desc": "(Lgraphql/schema/GraphQLInputSchemaElement;)Z",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$0",
+            "desc": "(Lgraphql/schema/GraphQLInputSchemaElement;)Z",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.InterfaceImplementedMoreThanOnceError": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/ImplementingTypeDefinition;Lgraphql/language/InterfaceTypeDefinition;)V",
+            "line": 12,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.SchemaMissingError": {
+        "line": {
+          "covered": 0,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 0,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 9,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.DirectiveIllegalArgumentTypeError": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Node;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkDirectiveIllegalArgumentTypeErrorMessage",
+            "desc": "(Lgraphql/language/Node;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.SchemaRedefinitionError": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/SchemaDefinition;Lgraphql/language/SchemaDefinition;)V",
+            "line": 12,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.TypeRedefinitionError": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/TypeDefinition;Lgraphql/language/TypeDefinition;)V",
+            "line": 12,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.MissingScalarImplementationError": {
+        "line": {
+          "covered": 0,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 0,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 11,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.NotAnInputTypeError": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Type;Lgraphql/language/TypeDefinition;)V",
+            "line": 13,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.MissingTypeResolverError": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/TypeDefinition;)V",
+            "line": 12,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.MissingTransitiveInterfaceError": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/ImplementingTypeDefinition;Lgraphql/language/InterfaceTypeDefinition;Lgraphql/language/InterfaceTypeDefinition;)V",
+            "line": 12,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.BaseError": {
+        "line": {
+          "covered": 7,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 2
+        },
+        "method": {
+          "covered": 4,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Node;Ljava/lang/String;)V",
+            "line": 21,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lineCol",
+            "desc": "(Lgraphql/language/Node;)Ljava/lang/String;",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocations",
+            "desc": "()Ljava/util/List;",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/ErrorType;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.UnionTypeError": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Node;Ljava/lang/String;)V",
+            "line": 9,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.StrictModeWiringException": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.NotAnOutputTypeError": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Type;Lgraphql/language/TypeDefinition;)V",
+            "line": 13,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.SchemaProblem": {
+        "line": {
+          "covered": 5,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;)V",
+            "line": 21,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMessage",
+            "desc": "()Ljava/lang/String;",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrors",
+            "desc": "()Ljava/util/List;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.DirectiveIllegalReferenceError": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/DirectiveDefinition;Lgraphql/language/NamedNode;)V",
+            "line": 10,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.MissingInterfaceTypeError": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/TypeDefinition;Lgraphql/language/TypeName;)V",
+            "line": 13,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.NonSDLDefinitionError": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Definition;)V",
+            "line": 12,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.NonUniqueArgumentError": {
+        "line": {
+          "covered": 9,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/TypeDefinition;Lgraphql/language/FieldDefinition;Ljava/lang/String;)V",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/TypeDefinition;Lgraphql/language/InputValueDefinition;Ljava/lang/String;)V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/TypeDefinition;Lgraphql/language/EnumValueDefinition;Ljava/lang/String;)V",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.DirectiveRedefinitionError": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/DirectiveDefinition;Lgraphql/language/DirectiveDefinition;)V",
+            "line": 12,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.QueryOperationMissingError": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 9,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.OperationTypesMustBeObjects": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/OperationTypeDefinition;)V",
+            "line": 12,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.NonUniqueNameError": {
+        "line": {
+          "covered": 15,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/TypeDefinition;Lgraphql/language/FieldDefinition;)V",
+            "line": 18,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/TypeDefinition;Lgraphql/language/InputValueDefinition;)V",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/InputObjectTypeDefinition;Lgraphql/language/InputValueDefinition;)V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/TypeDefinition;Lgraphql/language/EnumValueDefinition;)V",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/UnionTypeDefinition;Ljava/lang/String;)V",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/DirectiveDefinition;Lgraphql/language/InputValueDefinition;)V",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.TypeExtensionFieldRedefinitionError": {
+        "line": {
+          "covered": 8,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/TypeDefinition;Lgraphql/language/FieldDefinition;)V",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/TypeDefinition;Lgraphql/language/InputValueDefinition;)V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "formatMessage",
+            "desc": "(Lgraphql/language/TypeDefinition;Ljava/lang/String;Lgraphql/language/AbstractNode;)Ljava/lang/String;",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.InterfaceFieldRedefinitionError": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/ImplementingTypeDefinition;Lgraphql/language/InterfaceTypeDefinition;Lgraphql/language/FieldDefinition;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 13,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.IllegalNameError": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/NamedNode;)V",
+            "line": 9,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.MissingTypeError": {
+        "line": {
+          "covered": 9,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/TypeDefinition;Lgraphql/language/TypeName;)V",
+            "line": 14,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Node;Ljava/lang/String;Lgraphql/language/TypeName;)V",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Node;Ljava/lang/String;)V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.DirectiveUndeclaredError": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Node;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 12,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.InterfaceFieldArgumentRedefinitionError": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/ImplementingTypeDefinition;Lgraphql/language/InterfaceTypeDefinition;Lgraphql/language/FieldDefinition;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 14,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.TypeExtensionDirectiveRedefinitionError": {
+        "line": {
+          "covered": 0,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 0,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/TypeDefinition;Lgraphql/language/Directive;)V",
+            "line": 13,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.TypeExtensionEnumValueRedefinitionError": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/TypeDefinition;Lgraphql/language/EnumValueDefinition;)V",
+            "line": 13,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.DirectiveUnknownArgumentError": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Node;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 12,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.OperationRedefinitionError": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/OperationTypeDefinition;Lgraphql/language/OperationTypeDefinition;)V",
+            "line": 12,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.NonUniqueDirectiveError": {
+        "line": {
+          "covered": 0,
+          "missed": 9
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 0,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/TypeDefinition;Lgraphql/language/FieldDefinition;Ljava/lang/String;)V",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/TypeDefinition;Lgraphql/language/InputValueDefinition;Ljava/lang/String;)V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/TypeDefinition;Lgraphql/language/EnumValueDefinition;Ljava/lang/String;)V",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.InterfaceWithCircularImplementationHierarchyError": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/ImplementingTypeDefinition;Lgraphql/language/InterfaceTypeDefinition;)V",
+            "line": 12,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.TypeExtensionMissingBaseTypeError": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/TypeDefinition;)V",
+            "line": 12,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.InterfaceFieldArgumentNotOptionalError": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/ImplementingTypeDefinition;Lgraphql/language/InterfaceTypeDefinition;Lgraphql/language/FieldDefinition;Ljava/lang/String;)V",
+            "line": 13,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.DirectiveIllegalLocationError": {
+        "line": {
+          "covered": 8,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Node;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 13,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/DirectiveDefinition;Ljava/lang/String;)V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.MissingInterfaceFieldArgumentsError": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/ImplementingTypeDefinition;Lgraphql/language/InterfaceTypeDefinition;Lgraphql/language/FieldDefinition;)V",
+            "line": 13,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.DirectiveMissingNonNullArgumentError": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Node;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 12,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.InterfaceImplementingItselfError": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/ImplementingTypeDefinition;)V",
+            "line": 11,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.idl.errors.MissingInterfaceFieldError": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/ImplementingTypeDefinition;Lgraphql/language/InterfaceTypeDefinition;Lgraphql/language/FieldDefinition;)V",
+            "line": 13,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.MaxQueryDepthInstrumentation": {
+        "line": {
+          "covered": 28,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 6,
+          "missed": 0
+        },
+        "method": {
+          "covered": 8,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(I)V",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(ILjava/util/function/Function;)V",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginExecuteOperation",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecuteOperationParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkAbortException",
+            "desc": "(II)Lgraphql/execution/AbortExecutionException;",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newQueryTraverser",
+            "desc": "(Lgraphql/execution/ExecutionContext;)Lgraphql/analysis/QueryTraverser;",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPathLength",
+            "desc": "(Lgraphql/analysis/QueryVisitorFieldEnvironment;)I",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$beginExecuteOperation$0",
+            "desc": "(Lgraphql/analysis/QueryVisitorFieldEnvironment;Ljava/lang/Integer;)Ljava/lang/Integer;",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$0",
+            "desc": "(Lgraphql/analysis/QueryDepthInfo;)Ljava/lang/Boolean;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.QueryTransformer$Builder": {
+        "line": {
+          "covered": 13,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "schema",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Lgraphql/analysis/QueryTransformer$Builder;",
+            "line": 123,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "variables",
+            "desc": "(Ljava/util/Map;)Lgraphql/analysis/QueryTransformer$Builder;",
+            "line": 135,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "root",
+            "desc": "(Lgraphql/language/Node;)Lgraphql/analysis/QueryTransformer$Builder;",
+            "line": 147,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "rootParentType",
+            "desc": "(Lgraphql/schema/GraphQLCompositeType;)Lgraphql/analysis/QueryTransformer$Builder;",
+            "line": 159,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fragmentsByName",
+            "desc": "(Ljava/util/Map;)Lgraphql/analysis/QueryTransformer$Builder;",
+            "line": 171,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "options",
+            "desc": "(Lgraphql/analysis/QueryTraversalOptions;)Lgraphql/analysis/QueryTransformer$Builder;",
+            "line": 182,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/analysis/QueryTransformer;",
+            "line": 187,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.QueryComplexityCalculator$1": {
+        "line": {
+          "covered": 8,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/analysis/QueryComplexityCalculator;Ljava/util/Map;)V",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitField",
+            "desc": "(Lgraphql/analysis/QueryVisitorFieldEnvironment;)V",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitField$0",
+            "desc": "(ILgraphql/analysis/QueryVisitorFieldEnvironment;Ljava/lang/Integer;)Ljava/lang/Integer;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.QueryComplexityInfo$Builder": {
+        "line": {
+          "covered": 7,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "complexity",
+            "desc": "(I)Lgraphql/analysis/QueryComplexityInfo$Builder;",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "instrumentationValidationParameters",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationValidationParameters;)Lgraphql/analysis/QueryComplexityInfo$Builder;",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "instrumentationExecuteOperationParameters",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecuteOperationParameters;)Lgraphql/analysis/QueryComplexityInfo$Builder;",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/analysis/QueryComplexityInfo;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.QueryTraversalOptions": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Z)V",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isCoerceFieldArguments",
+            "desc": "()Z",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "defaultOptions",
+            "desc": "()Lgraphql/analysis/QueryTraversalOptions;",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "coerceFieldArguments",
+            "desc": "(Z)Lgraphql/analysis/QueryTraversalOptions;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.QueryTransformer": {
+        "line": {
+          "covered": 15,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/Node;Lgraphql/schema/GraphQLCompositeType;Ljava/util/Map;Ljava/util/Map;Lgraphql/analysis/QueryTraversalOptions;)V",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Lgraphql/analysis/QueryVisitor;)Lgraphql/language/Node;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newQueryTransformer",
+            "desc": "()Lgraphql/analysis/QueryTransformer$Builder;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.QueryVisitor": {
+        "line": {
+          "covered": 5,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "visitFieldWithControl",
+            "desc": "(Lgraphql/analysis/QueryVisitorFieldEnvironment;)Lgraphql/util/TraversalControl;",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitFragmentDefinition",
+            "desc": "(Lgraphql/analysis/QueryVisitorFragmentDefinitionEnvironment;)V",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitArgument",
+            "desc": "(Lgraphql/analysis/QueryVisitorFieldArgumentEnvironment;)Lgraphql/util/TraversalControl;",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitArgumentValue",
+            "desc": "(Lgraphql/analysis/QueryVisitorFieldArgumentValueEnvironment;)Lgraphql/util/TraversalControl;",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.QueryTraversalContext": {
+        "line": {
+          "covered": 11,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLOutputType;Lgraphql/analysis/QueryVisitorFieldEnvironment;Lgraphql/language/SelectionSetContainer;Lgraphql/GraphQLContext;)V",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOutputType",
+            "desc": "()Lgraphql/schema/GraphQLOutputType;",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getUnwrappedOutputType",
+            "desc": "()Lgraphql/schema/GraphQLCompositeType;",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getEnvironment",
+            "desc": "()Lgraphql/analysis/QueryVisitorFieldEnvironment;",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSelectionSetContainer",
+            "desc": "()Lgraphql/language/SelectionSetContainer;",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getGraphQLContext",
+            "desc": "()Lgraphql/GraphQLContext;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.QueryDepthInfo": {
+        "line": {
+          "covered": 4,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(I)V",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDepth",
+            "desc": "()I",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "newQueryDepthInfo",
+            "desc": "()Lgraphql/analysis/QueryDepthInfo$Builder;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.NodeVisitorWithTypeTracking": {
+        "line": {
+          "covered": 120,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 34,
+          "missed": 2
+        },
+        "method": {
+          "covered": 9,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/analysis/QueryVisitor;Lgraphql/analysis/QueryVisitor;Ljava/util/Map;Lgraphql/schema/GraphQLSchema;Ljava/util/Map;Lgraphql/analysis/QueryTraversalOptions;)V",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitDirective",
+            "desc": "(Lgraphql/language/Directive;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitInlineFragment",
+            "desc": "(Lgraphql/language/InlineFragment;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitFragmentDefinition",
+            "desc": "(Lgraphql/language/FragmentDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 109,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitFragmentSpread",
+            "desc": "(Lgraphql/language/FragmentSpread;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitField",
+            "desc": "(Lgraphql/language/Field;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 160,
+            "counters": {
+              "line": {
+                "covered": 30,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 12,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitArgument",
+            "desc": "(Lgraphql/language/Argument;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 213,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitObjectField",
+            "desc": "(Lgraphql/language/ObjectField;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 242,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitValue",
+            "desc": "(Lgraphql/language/Value;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 258,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.FieldComplexityEnvironment": {
+        "line": {
+          "covered": 8,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 5
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Field;Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/GraphQLCompositeType;Ljava/util/Map;Lgraphql/analysis/FieldComplexityEnvironment;)V",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getField",
+            "desc": "()Lgraphql/language/Field;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinition",
+            "desc": "()Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getParentType",
+            "desc": "()Lgraphql/schema/GraphQLCompositeType;",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getParentEnvironment",
+            "desc": "()Lgraphql/analysis/FieldComplexityEnvironment;",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getArguments",
+            "desc": "()Ljava/util/Map;",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.QueryTraverser$2": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/analysis/QueryTraverser;[Ljava/lang/Object;Lgraphql/analysis/QueryReducer;)V",
+            "line": 159,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitField",
+            "desc": "(Lgraphql/analysis/QueryVisitorFieldEnvironment;)V",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.QueryTraverser$1": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/analysis/QueryTraverser;[Ljava/lang/Object;Lgraphql/analysis/QueryReducer;)V",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitField",
+            "desc": "(Lgraphql/analysis/QueryVisitorFieldEnvironment;)V",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.QueryVisitorFragmentDefinitionEnvironmentImpl": {
+        "line": {
+          "covered": 7,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/FragmentDefinition;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLSchema;)V",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSchema",
+            "desc": "()Lgraphql/schema/GraphQLSchema;",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getFragmentDefinition",
+            "desc": "()Lgraphql/language/FragmentDefinition;",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTraverserContext",
+            "desc": "()Lgraphql/util/TraverserContext;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.QueryComplexityCalculator": {
+        "line": {
+          "covered": 31,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/analysis/QueryComplexityCalculator$Builder;)V",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "calculate",
+            "desc": "()I",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "calculateByParents",
+            "desc": "()Ljava/util/Map;",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "calculateComplexity",
+            "desc": "(Lgraphql/analysis/QueryVisitorFieldEnvironment;I)I",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "convertEnv",
+            "desc": "(Lgraphql/analysis/QueryVisitorFieldEnvironment;)Lgraphql/analysis/FieldComplexityEnvironment;",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newCalculator",
+            "desc": "()Lgraphql/analysis/QueryComplexityCalculator$Builder;",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.QueryVisitorFieldArgumentInputValueImpl": {
+        "line": {
+          "covered": 13,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 9,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/analysis/QueryVisitorFieldArgumentInputValue;Lgraphql/schema/GraphQLInputValueDefinition;Lgraphql/language/Value;)V",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "incompleteArgumentInputValue",
+            "desc": "(Lgraphql/schema/GraphQLArgument;)Lgraphql/analysis/QueryVisitorFieldArgumentInputValue;",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "incompleteNewChild",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;)Lgraphql/analysis/QueryVisitorFieldArgumentInputValueImpl;",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "completeArgumentInputValue",
+            "desc": "(Lgraphql/language/Value;)Lgraphql/analysis/QueryVisitorFieldArgumentInputValueImpl;",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParent",
+            "desc": "()Lgraphql/analysis/QueryVisitorFieldArgumentInputValue;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInputValueDefinition",
+            "desc": "()Lgraphql/schema/GraphQLInputValueDefinition;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInputType",
+            "desc": "()Lgraphql/schema/GraphQLInputType;",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getValue",
+            "desc": "()Lgraphql/language/Value;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.QueryTransformer$1": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/analysis/QueryTransformer;Lgraphql/analysis/NodeVisitorWithTypeTracking;)V",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enter",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "leave",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.MaxQueryComplexityInstrumentation": {
+        "line": {
+          "covered": 36,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 1
+        },
+        "method": {
+          "covered": 12,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(I)V",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(ILjava/util/function/Function;)V",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(ILgraphql/analysis/FieldComplexityCalculator;)V",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(ILgraphql/analysis/FieldComplexityCalculator;Ljava/util/function/Function;)V",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createStateAsync",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationCreateStateParameters;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginValidation",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationValidationParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginExecuteOperation",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecuteOperationParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 97,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newQueryComplexityCalculator",
+            "desc": "(Lgraphql/execution/ExecutionContext;)Lgraphql/analysis/QueryComplexityCalculator;",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkAbortException",
+            "desc": "(II)Lgraphql/execution/AbortExecutionException;",
+            "line": 133,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$2",
+            "desc": "(Lgraphql/analysis/QueryComplexityInfo;)Ljava/lang/Boolean;",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$1",
+            "desc": "(Lgraphql/analysis/FieldComplexityEnvironment;I)I",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$0",
+            "desc": "(Lgraphql/analysis/QueryComplexityInfo;)Ljava/lang/Boolean;",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.QueryComplexityCalculator$Builder": {
+        "line": {
+          "covered": 13,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "schema",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Lgraphql/analysis/QueryComplexityCalculator$Builder;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldComplexityCalculator",
+            "desc": "(Lgraphql/analysis/FieldComplexityCalculator;)Lgraphql/analysis/QueryComplexityCalculator$Builder;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "document",
+            "desc": "(Lgraphql/language/Document;)Lgraphql/analysis/QueryComplexityCalculator$Builder;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "operationName",
+            "desc": "(Ljava/lang/String;)Lgraphql/analysis/QueryComplexityCalculator$Builder;",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "variables",
+            "desc": "(Lgraphql/execution/CoercedVariables;)Lgraphql/analysis/QueryComplexityCalculator$Builder;",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/analysis/QueryComplexityCalculator;",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.QueryTraverser": {
+        "line": {
+          "covered": 59,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 11,
+          "missed": 1
+        },
+        "method": {
+          "covered": 12,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/Document;Ljava/lang/String;Lgraphql/execution/CoercedVariables;Lgraphql/analysis/QueryTraversalOptions;)V",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/Document;Ljava/lang/String;Lgraphql/execution/RawVariables;Lgraphql/analysis/QueryTraversalOptions;)V",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/Node;Lgraphql/schema/GraphQLCompositeType;Ljava/util/Map;Lgraphql/execution/CoercedVariables;Lgraphql/analysis/QueryTraversalOptions;)V",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitDepthFirst",
+            "desc": "(Lgraphql/analysis/QueryVisitor;)Ljava/lang/Object;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitPostOrder",
+            "desc": "(Lgraphql/analysis/QueryVisitor;)V",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitPreOrder",
+            "desc": "(Lgraphql/analysis/QueryVisitor;)V",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "reducePostOrder",
+            "desc": "(Lgraphql/analysis/QueryReducer;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "reducePreOrder",
+            "desc": "(Lgraphql/analysis/QueryReducer;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 158,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getRootTypeFromOperation",
+            "desc": "(Lgraphql/language/OperationDefinition;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 169,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "childrenOf",
+            "desc": "(Lgraphql/language/Node;)Ljava/util/List;",
+            "line": 182,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitImpl",
+            "desc": "(Lgraphql/analysis/QueryVisitor;Ljava/lang/Boolean;)Ljava/lang/Object;",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newQueryTraverser",
+            "desc": "()Lgraphql/analysis/QueryTraverser$Builder;",
+            "line": 215,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.QueryVisitorFieldEnvironmentImpl": {
+        "line": {
+          "covered": 23,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 10,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(ZLgraphql/language/Field;Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/GraphQLOutputType;Lgraphql/schema/GraphQLFieldsContainer;Lgraphql/analysis/QueryVisitorFieldEnvironment;Ljava/util/Map;Lgraphql/language/SelectionSetContainer;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLSchema;)V",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSchema",
+            "desc": "()Lgraphql/schema/GraphQLSchema;",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getField",
+            "desc": "()Lgraphql/language/Field;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinition",
+            "desc": "()Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParentType",
+            "desc": "()Lgraphql/schema/GraphQLOutputType;",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParentEnvironment",
+            "desc": "()Lgraphql/analysis/QueryVisitorFieldEnvironment;",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArguments",
+            "desc": "()Ljava/util/Map;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSelectionSetContainer",
+            "desc": "()Lgraphql/language/SelectionSetContainer;",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldsContainer",
+            "desc": "()Lgraphql/schema/GraphQLFieldsContainer;",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isTypeNameIntrospectionField",
+            "desc": "()Z",
+            "line": 97,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTraverserContext",
+            "desc": "()Lgraphql/util/TraverserContext;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.MaxQueryComplexityInstrumentation$State": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.QueryVisitorStub": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 8,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitField",
+            "desc": "(Lgraphql/analysis/QueryVisitorFieldEnvironment;)V",
+            "line": 14,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitInlineFragment",
+            "desc": "(Lgraphql/analysis/QueryVisitorInlineFragmentEnvironment;)V",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitFragmentSpread",
+            "desc": "(Lgraphql/analysis/QueryVisitorFragmentSpreadEnvironment;)V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.QueryVisitorFieldArgumentEnvironmentImpl": {
+        "line": {
+          "covered": 13,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 6
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/language/Argument;Lgraphql/schema/GraphQLArgument;Ljava/lang/Object;Ljava/util/Map;Lgraphql/analysis/QueryVisitorFieldEnvironment;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLSchema;)V",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSchema",
+            "desc": "()Lgraphql/schema/GraphQLSchema;",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getArgument",
+            "desc": "()Lgraphql/language/Argument;",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinition",
+            "desc": "()Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getGraphQLArgument",
+            "desc": "()Lgraphql/schema/GraphQLArgument;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentValue",
+            "desc": "()Ljava/lang/Object;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getVariables",
+            "desc": "()Ljava/util/Map;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getParentEnvironment",
+            "desc": "()Lgraphql/analysis/QueryVisitorFieldEnvironment;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getTraverserContext",
+            "desc": "()Lgraphql/util/TraverserContext;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.QueryVisitorInlineFragmentEnvironmentImpl": {
+        "line": {
+          "covered": 7,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/InlineFragment;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLSchema;)V",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSchema",
+            "desc": "()Lgraphql/schema/GraphQLSchema;",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getInlineFragment",
+            "desc": "()Lgraphql/language/InlineFragment;",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTraverserContext",
+            "desc": "()Lgraphql/util/TraverserContext;",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.QueryDepthInfo$Builder": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "depth",
+            "desc": "(I)Lgraphql/analysis/QueryDepthInfo$Builder;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/analysis/QueryDepthInfo;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.QueryVisitorFragmentSpreadEnvironmentImpl": {
+        "line": {
+          "covered": 9,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/FragmentSpread;Lgraphql/language/FragmentDefinition;Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLSchema;)V",
+            "line": 21,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSchema",
+            "desc": "()Lgraphql/schema/GraphQLSchema;",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getFragmentSpread",
+            "desc": "()Lgraphql/language/FragmentSpread;",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFragmentDefinition",
+            "desc": "()Lgraphql/language/FragmentDefinition;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTraverserContext",
+            "desc": "()Lgraphql/util/TraverserContext;",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.QueryComplexityInfo": {
+        "line": {
+          "covered": 8,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/analysis/QueryComplexityInfo$Builder;)V",
+            "line": 21,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getComplexity",
+            "desc": "()I",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getInstrumentationValidationParameters",
+            "desc": "()Lgraphql/execution/instrumentation/parameters/InstrumentationValidationParameters;",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInstrumentationExecuteOperationParameters",
+            "desc": "()Lgraphql/execution/instrumentation/parameters/InstrumentationExecuteOperationParameters;",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "newQueryComplexityInfo",
+            "desc": "()Lgraphql/analysis/QueryComplexityInfo$Builder;",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.QueryVisitorFieldArgumentValueEnvironmentImpl": {
+        "line": {
+          "covered": 10,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 5
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/GraphQLArgument;Lgraphql/analysis/QueryVisitorFieldArgumentInputValue;Lgraphql/util/TraverserContext;Ljava/util/Map;)V",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSchema",
+            "desc": "()Lgraphql/schema/GraphQLSchema;",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinition",
+            "desc": "()Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getGraphQLArgument",
+            "desc": "()Lgraphql/schema/GraphQLArgument;",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentInputValue",
+            "desc": "()Lgraphql/analysis/QueryVisitorFieldArgumentInputValue;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getVariables",
+            "desc": "()Ljava/util/Map;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getTraverserContext",
+            "desc": "()Lgraphql/util/TraverserContext;",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 63,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.analysis.QueryTraverser$Builder": {
+        "line": {
+          "covered": 36,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 13,
+          "missed": 3
+        },
+        "method": {
+          "covered": 12,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 220,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "schema",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Lgraphql/analysis/QueryTraverser$Builder;",
+            "line": 241,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "operationName",
+            "desc": "(Ljava/lang/String;)Lgraphql/analysis/QueryTraverser$Builder;",
+            "line": 254,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "document",
+            "desc": "(Lgraphql/language/Document;)Lgraphql/analysis/QueryTraverser$Builder;",
+            "line": 267,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "variables",
+            "desc": "(Ljava/util/Map;)Lgraphql/analysis/QueryTraverser$Builder;",
+            "line": 279,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "coercedVariables",
+            "desc": "(Lgraphql/execution/CoercedVariables;)Lgraphql/analysis/QueryTraverser$Builder;",
+            "line": 292,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "root",
+            "desc": "(Lgraphql/language/Node;)Lgraphql/analysis/QueryTraverser$Builder;",
+            "line": 306,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "rootParentType",
+            "desc": "(Lgraphql/schema/GraphQLCompositeType;)Lgraphql/analysis/QueryTraverser$Builder;",
+            "line": 318,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fragmentsByName",
+            "desc": "(Ljava/util/Map;)Lgraphql/analysis/QueryTraverser$Builder;",
+            "line": 330,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "options",
+            "desc": "(Lgraphql/analysis/QueryTraversalOptions;)Lgraphql/analysis/QueryTraverser$Builder;",
+            "line": 341,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/analysis/QueryTraverser;",
+            "line": 349,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkState",
+            "desc": "()V",
+            "line": 385,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.fieldvalidation.FieldValidationSupport$FieldAndArgError": {
+        "line": {
+          "covered": 8,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Field;Lgraphql/execution/ResultPath;)V",
+            "line": 179,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMessage",
+            "desc": "()Ljava/lang/String;",
+            "line": 187,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/ErrorType;",
+            "line": 192,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getLocations",
+            "desc": "()Ljava/util/List;",
+            "line": 197,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPath",
+            "desc": "()Ljava/util/List;",
+            "line": 202,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.fieldvalidation.FieldValidationSupport": {
+        "line": {
+          "covered": 10,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "validateFieldsAndArguments",
+            "desc": "(Lgraphql/execution/instrumentation/fieldvalidation/FieldValidation;Lgraphql/execution/ExecutionContext;)Ljava/util/List;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.fieldvalidation.FieldValidationSupport$1": {
+        "line": {
+          "covered": 9,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 1
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Map;)V",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitField",
+            "desc": "(Lgraphql/analysis/QueryVisitorFieldEnvironment;)V",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.fieldvalidation.SimpleFieldValidation": {
+        "line": {
+          "covered": 16,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 6,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addRule",
+            "desc": "(Lgraphql/execution/ResultPath;Ljava/util/function/BiFunction;)Lgraphql/execution/instrumentation/fieldvalidation/SimpleFieldValidation;",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateFields",
+            "desc": "(Lgraphql/execution/instrumentation/fieldvalidation/FieldValidationEnvironment;)Ljava/util/List;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.fieldvalidation.FieldValidationInstrumentation": {
+        "line": {
+          "covered": 7,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 1
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/instrumentation/fieldvalidation/FieldValidation;)V",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginExecuteOperation",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecuteOperationParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.fieldvalidation.FieldValidationSupport$FieldAndArgumentsImpl": {
+        "line": {
+          "covered": 25,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 8,
+          "missed": 0
+        },
+        "method": {
+          "covered": 8,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/analysis/QueryVisitorFieldEnvironment;)V",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkParentArgs",
+            "desc": "(Lgraphql/analysis/QueryVisitorFieldEnvironment;)Lgraphql/execution/instrumentation/fieldvalidation/FieldAndArguments;",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkPath",
+            "desc": "(Lgraphql/analysis/QueryVisitorFieldEnvironment;)Lgraphql/execution/ResultPath;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getField",
+            "desc": "()Lgraphql/language/Field;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinition",
+            "desc": "()Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getParentType",
+            "desc": "()Lgraphql/schema/GraphQLCompositeType;",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getPath",
+            "desc": "()Lgraphql/execution/ResultPath;",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentValuesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentValue",
+            "desc": "(Ljava/lang/String;)Ljava/lang/Object;",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParentFieldAndArguments",
+            "desc": "()Lgraphql/execution/instrumentation/fieldvalidation/FieldAndArguments;",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.fieldvalidation.FieldValidationSupport$FieldValidationEnvironmentImpl": {
+        "line": {
+          "covered": 9,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/ExecutionContext;Ljava/util/Map;)V",
+            "line": 141,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExecutionContext",
+            "desc": "()Lgraphql/execution/ExecutionContext;",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getFields",
+            "desc": "()Ljava/util/List;",
+            "line": 155,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldsByPath",
+            "desc": "()Ljava/util/Map;",
+            "line": 160,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkError",
+            "desc": "(Ljava/lang/String;)Lgraphql/GraphQLError;",
+            "line": 165,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkError",
+            "desc": "(Ljava/lang/String;Lgraphql/execution/instrumentation/fieldvalidation/FieldAndArguments;)Lgraphql/GraphQLError;",
+            "line": 170,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.TreeTransformerUtil": {
+        "line": {
+          "covered": 56,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 15,
+          "missed": 1
+        },
+        "method": {
+          "covered": 6,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 11,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "changeNode",
+            "desc": "(Lgraphql/util/TraverserContext;Ljava/lang/Object;)Lgraphql/util/TraversalControl;",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 19,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceZipperForNode",
+            "desc": "(Ljava/util/List;Ljava/lang/Object;Ljava/lang/Object;)V",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deleteNode",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "insertAfter",
+            "desc": "(Lgraphql/util/TraverserContext;Ljava/lang/Object;)Lgraphql/util/TraversalControl;",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "insertBefore",
+            "desc": "(Lgraphql/util/TraverserContext;Ljava/lang/Object;)Lgraphql/util/TraversalControl;",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$replaceZipperForNode$0",
+            "desc": "(Ljava/lang/Object;Lgraphql/util/NodeZipper;)Z",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.EscapeUtil": {
+        "line": {
+          "covered": 23,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 10,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "escapeJsonString",
+            "desc": "(Ljava/lang/String;)Ljava/lang/String;",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "escapeJsonStringTo",
+            "desc": "(Ljava/lang/StringBuilder;Ljava/lang/String;)V",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 20,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.Anonymizer$AnonymizeResult": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Ljava/util/List;)V",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSchema",
+            "desc": "()Lgraphql/schema/GraphQLSchema;",
+            "line": 122,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getQueries",
+            "desc": "()Ljava/util/List;",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.LinkedHashMapFactory": {
+        "line": {
+          "covered": 1,
+          "missed": 83
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 4
+        },
+        "method": {
+          "covered": 1,
+          "missed": 11
+        },
+        "methods": [
+          {
+            "name": "of",
+            "desc": "()Ljava/util/Map;",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/Map;",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/Map;",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/Map;",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 5
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/Map;",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 6
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/Map;",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 7
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/Map;",
+            "line": 158,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 8
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/Map;",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 9
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/Map;",
+            "line": 225,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 10
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/Map;",
+            "line": 263,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 11
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/Map;",
+            "line": 304,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 12
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "ofEntries",
+            "desc": "([Ljava/lang/Object;)Ljava/util/Map;",
+            "line": 332,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 8
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 4
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.InterThreadMemoizedSupplier": {
+        "line": {
+          "covered": 12,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 1
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/function/Supplier;)V",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "get",
+            "desc": "()Ljava/lang/Object;",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.ReplaceNode": {
+        "line": {
+          "covered": 0,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 0,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 14,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getNewNode",
+            "desc": "()Ljava/lang/Object;",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.TraversalControl": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 8,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.LockKit$ReentrantLock": {
+        "line": {
+          "covered": 13,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lock",
+            "desc": "()V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unlock",
+            "desc": "()V",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "runLocked",
+            "desc": "(Ljava/lang/Runnable;)V",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "callLocked",
+            "desc": "(Ljava/util/function/Supplier;)Ljava/lang/Object;",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.CyclicSchemaAnalyzer$FindCyclesImpl": {
+        "line": {
+          "covered": 160,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 61,
+          "missed": 3
+        },
+        "method": {
+          "covered": 13,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)V",
+            "line": 124,
+            "counters": {
+              "line": {
+                "covered": 24,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "findAllSimpleCyclesImpl",
+            "desc": "()Ljava/util/List;",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "findMinSCSG",
+            "desc": "(I)Lgraphql/util/CyclicSchemaAnalyzer$GraphAndIndex;",
+            "line": 186,
+            "counters": {
+              "line": {
+                "covered": 28,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 16,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "findSCCS",
+            "desc": "(I)Ljava/util/List;",
+            "line": 235,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSCCs",
+            "desc": "(II)V",
+            "line": 250,
+            "counters": {
+              "line": {
+                "covered": 30,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 15,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "findCyclesInSCG",
+            "desc": "(IILgraphql/schema/diffing/SchemaGraph;)Z",
+            "line": 294,
+            "counters": {
+              "line": {
+                "covered": 25,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 14,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unblock",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)V",
+            "line": 326,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "initMinSCGState",
+            "desc": "()V",
+            "line": 339,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clearMinSCCState",
+            "desc": "()V",
+            "line": 348,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toI",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Ljava/lang/Integer;",
+            "line": 357,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toV",
+            "desc": "(Ljava/lang/Integer;)Lgraphql/schema/diffing/Vertex;",
+            "line": 361,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getBSet",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Ljava/util/Set;",
+            "line": 367,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getBSet$0",
+            "desc": "(Lgraphql/schema/diffing/Vertex;)Ljava/util/Set;",
+            "line": 367,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.NodeLocation": {
+        "line": {
+          "covered": 6,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;I)V",
+            "line": 18,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getIndex",
+            "desc": "()I",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.TreeParallelTraverser": {
+        "line": {
+          "covered": 36,
+          "missed": 10
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 1
+        },
+        "method": {
+          "covered": 12,
+          "missed": 7
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/function/Function;Ljava/lang/Object;Ljava/util/concurrent/ForkJoinPool;)V",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parallelTraverser",
+            "desc": "(Ljava/util/function/Function;)Lgraphql/util/TreeParallelTraverser;",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "parallelTraverser",
+            "desc": "(Ljava/util/function/Function;Ljava/lang/Object;)Lgraphql/util/TreeParallelTraverser;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parallelTraverser",
+            "desc": "(Ljava/util/function/Function;Ljava/lang/Object;Ljava/util/concurrent/ForkJoinPool;)Lgraphql/util/TreeParallelTraverser;",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "parallelTraverserWithNamedChildren",
+            "desc": "(Ljava/util/function/Function;Ljava/lang/Object;)Lgraphql/util/TreeParallelTraverser;",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "parallelTraverserWithNamedChildren",
+            "desc": "(Ljava/util/function/Function;Ljava/lang/Object;Ljava/util/concurrent/ForkJoinPool;)Lgraphql/util/TreeParallelTraverser;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "wrapListFunction",
+            "desc": "(Ljava/util/function/Function;)Ljava/util/function/Function;",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "rootVars",
+            "desc": "(Ljava/util/Map;)Lgraphql/util/TreeParallelTraverser;",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "rootVar",
+            "desc": "(Ljava/lang/Class;Ljava/lang/Object;)Lgraphql/util/TreeParallelTraverser;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "traverse",
+            "desc": "(Ljava/lang/Object;Lgraphql/util/TraverserVisitor;)V",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "traverse",
+            "desc": "(Ljava/util/Collection;Lgraphql/util/TraverserVisitor;)V",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newRootContext",
+            "desc": "(Ljava/util/Map;)Lgraphql/util/DefaultTraverserContext;",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "traverseImpl",
+            "desc": "(Ljava/util/Collection;Lgraphql/util/TraverserVisitor;)V",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "pushAll",
+            "desc": "(Lgraphql/util/TraverserContext;)Ljava/util/List;",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newContext",
+            "desc": "(Ljava/lang/Object;Lgraphql/util/TraverserContext;Lgraphql/util/NodeLocation;)Lgraphql/util/DefaultTraverserContext;",
+            "line": 178,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newContextImpl",
+            "desc": "(Ljava/lang/Object;Lgraphql/util/TraverserContext;Ljava/util/Map;Lgraphql/util/NodeLocation;Z)Lgraphql/util/DefaultTraverserContext;",
+            "line": 186,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$pushAll$0",
+            "desc": "(Ljava/util/Map;Lgraphql/util/TraverserContext;Ljava/util/LinkedList;Ljava/util/Map;Ljava/lang/String;)V",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$pushAll$1",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 169,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$wrapListFunction$0",
+            "desc": "(Ljava/util/function/Function;Ljava/lang/Object;)Ljava/util/Map;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.NodeZipper$ModificationType": {
+        "line": {
+          "covered": 5,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.Pair": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;)V",
+            "line": 8,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "pair",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;)Lgraphql/util/Pair;",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.LockKit$ComputedOnce": {
+        "line": {
+          "covered": 13,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 1
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasBeenComputed",
+            "desc": "()Z",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "runOnce",
+            "desc": "(Ljava/lang/Runnable;)V",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$runOnce$0",
+            "desc": "(Ljava/lang/Runnable;)V",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.TraverserVisitorStub": {
+        "line": {
+          "covered": 2,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 6,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enter",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 11,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "leave",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.TreeParallelTransformer$EnterAction": {
+        "line": {
+          "covered": 81,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 30,
+          "missed": 3
+        },
+        "method": {
+          "covered": 6,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/util/TreeParallelTransformer;Ljava/util/concurrent/CountedCompleter;Lgraphql/util/DefaultTraverserContext;Lgraphql/util/TraverserVisitor;)V",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "compute",
+            "desc": "()V",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 19,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onCompletion",
+            "desc": "(Ljava/util/concurrent/CountedCompleter;)V",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 18,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getRawResult",
+            "desc": "()Ljava/lang/Object;",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "moveUp",
+            "desc": "(Ljava/lang/Object;Ljava/util/List;)Lgraphql/util/NodeZipper;",
+            "line": 154,
+            "counters": {
+              "line": {
+                "covered": 26,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$moveUp$0",
+            "desc": "(Lgraphql/util/NodeZipper;Lgraphql/util/NodeZipper;)I",
+            "line": 160,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.CyclicSchemaAnalyzer": {
+        "line": {
+          "covered": 31,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 21,
+          "missed": 1
+        },
+        "method": {
+          "covered": 3,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "findCycles",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Ljava/util/List;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "findCycles",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Z)Ljava/util/List;",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 25,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 17,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$findCycles$0",
+            "desc": "(Ljava/util/List;)Z",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.LockKit": {
+        "line": {
+          "covered": 0,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 0,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 14,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.TraverserResult": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 10,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAccumulatedResult",
+            "desc": "()Ljava/lang/Object;",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.Breadcrumb": {
+        "line": {
+          "covered": 6,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Object;Lgraphql/util/NodeLocation;)V",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNode",
+            "desc": "()Ljava/lang/Object;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocation",
+            "desc": "()Lgraphql/util/NodeLocation;",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.TraverserState$EndList": {
+        "line": {
+          "covered": 1,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.TreeParallelTraverser$EnterAction": {
+        "line": {
+          "covered": 20,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 7,
+          "missed": 3
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/util/TreeParallelTraverser;Ljava/util/concurrent/CountedCompleter;Lgraphql/util/DefaultTraverserContext;Lgraphql/util/TraverserVisitor;)V",
+            "line": 124,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "compute",
+            "desc": "()V",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.IntraThreadMemoizedSupplier": {
+        "line": {
+          "covered": 10,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/function/Supplier;)V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "get",
+            "desc": "()Ljava/lang/Object;",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.TraverserContext$Phase": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 21,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.TreeTransformer$1": {
+        "line": {
+          "covered": 7,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/util/TreeTransformer;Lgraphql/util/TraverserVisitor;)V",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enter",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "leave",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "backRef",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.TraverserState$QueueTraverserState": {
+        "line": {
+          "covered": 20,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "pushAll",
+            "desc": "(Lgraphql/util/TraverserContext;Ljava/util/function/Function;)V",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$pushAll$0",
+            "desc": "(Ljava/util/Map;Lgraphql/util/TraverserContext;Ljava/util/Map;Ljava/lang/String;)V",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$pushAll$1",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.StringKit": {
+        "line": {
+          "covered": 7,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 6,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 5,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "capitalize",
+            "desc": "(Ljava/lang/String;)Ljava/lang/String;",
+            "line": 8,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.Anonymizer": {
+        "line": {
+          "covered": 155,
+          "missed": 7
+        },
+        "branch": {
+          "covered": 49,
+          "missed": 3
+        },
+        "method": {
+          "covered": 16,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "anonymizeSchema",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLSchema;",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "anonymizeSchema",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Lgraphql/schema/GraphQLSchema;",
+            "line": 135,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "anonymizeSchemaAndQueries",
+            "desc": "(Ljava/lang/String;Ljava/util/List;)Lgraphql/util/Anonymizer$AnonymizeResult;",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "anonymizeSchemaAndQueries",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Ljava/util/List;)Lgraphql/util/Anonymizer$AnonymizeResult;",
+            "line": 143,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "anonymizeSchemaAndQueries",
+            "desc": "(Ljava/lang/String;Ljava/util/List;Ljava/util/Map;)Lgraphql/util/Anonymizer$AnonymizeResult;",
+            "line": 147,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "anonymizeSchemaAndQueries",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Ljava/util/List;Ljava/util/Map;)Lgraphql/util/Anonymizer$AnonymizeResult;",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceValue",
+            "desc": "(Lgraphql/language/Value;Lgraphql/schema/GraphQLInputType;Ljava/util/Map;Ljava/util/concurrent/atomic/AtomicInteger;Ljava/util/concurrent/atomic/AtomicInteger;)Lgraphql/language/Value;",
+            "line": 382,
+            "counters": {
+              "line": {
+                "covered": 31,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 14,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "recordNewNamesForSchema",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Ljava/util/Map;",
+            "line": 421,
+            "counters": {
+              "line": {
+                "covered": 21,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSameFields",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/util/Map;Lgraphql/schema/GraphQLSchema;)Ljava/util/Set;",
+            "line": 646,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSameFieldsImpl",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/util/Map;Lgraphql/schema/GraphQLSchema;Ljava/util/Set;Ljava/util/Set;)V",
+            "line": 658,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMatchingFieldDefinitions",
+            "desc": "(Ljava/lang/String;Ljava/util/List;Ljava/util/Set;)V",
+            "line": 686,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMatchingArgumentDefinitions",
+            "desc": "(Ljava/lang/String;Ljava/util/Set;)Ljava/util/List;",
+            "line": 697,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "rewriteQuery",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLSchema;Ljava/util/Map;Ljava/util/Map;)Ljava/lang/String;",
+            "line": 705,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fromTypeToGraphQLType",
+            "desc": "(Lgraphql/language/Type;Lgraphql/schema/GraphQLSchema;)Lgraphql/schema/GraphQLType;",
+            "line": 911,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceTypeName",
+            "desc": "(Lgraphql/language/Type;Ljava/lang/String;)Lgraphql/language/Type;",
+            "line": 926,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertUniqueOperation",
+            "desc": "(Lgraphql/language/Document;)V",
+            "line": 938,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$recordNewNamesForSchema$1",
+            "desc": "(Ljava/util/Map;Ljava/util/Map;Ljava/util/concurrent/atomic/AtomicInteger;Lgraphql/schema/GraphQLNamedSchemaElement;Ljava/lang/String;)V",
+            "line": 455,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$recordNewNamesForSchema$0",
+            "desc": "(Ljava/util/Map;Ljava/util/Map;Ljava/util/concurrent/atomic/AtomicInteger;Lgraphql/schema/GraphQLNamedSchemaElement;)V",
+            "line": 443,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$replaceValue$0",
+            "desc": "(Ljava/util/Map;Lgraphql/schema/GraphQLInputObjectField;Lgraphql/language/Value;Lgraphql/schema/GraphQLInputType;Ljava/util/concurrent/atomic/AtomicInteger;Ljava/util/concurrent/atomic/AtomicInteger;Lgraphql/language/ObjectField$Builder;)V",
+            "line": 410,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.TreeParallelTraverser$1": {
+        "line": {
+          "covered": 9,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/util/TreeParallelTraverser;Ljava/util/Collection;Lgraphql/util/DefaultTraverserContext;Lgraphql/util/TraverserVisitor;)V",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "compute",
+            "desc": "()V",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.TraverserVisitor": {
+        "line": {
+          "covered": 1,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "backRef",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.IntraThreadMemoizedSupplier$1": {
+        "line": {
+          "covered": 1,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.NodeMultiZipper": {
+        "line": {
+          "covered": 72,
+          "missed": 19
+        },
+        "branch": {
+          "covered": 21,
+          "missed": 10
+        },
+        "method": {
+          "covered": 9,
+          "missed": 10
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Object;Ljava/util/List;Lgraphql/util/NodeAdapter;)V",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Object;Ljava/util/List;Lgraphql/util/NodeAdapter;Ljava/lang/Object;)V",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newNodeMultiZipperTrusted",
+            "desc": "(Ljava/lang/Object;Ljava/util/List;Lgraphql/util/NodeAdapter;)Lgraphql/util/NodeMultiZipper;",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toRootNode",
+            "desc": "()Ljava/lang/Object;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 19,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCommonRoot",
+            "desc": "()Ljava/lang/Object;",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getZippers",
+            "desc": "()Ljava/util/List;",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "size",
+            "desc": "()I",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getZipperForNode",
+            "desc": "(Ljava/lang/Object;)Lgraphql/util/NodeZipper;",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "withReplacedZippers",
+            "desc": "(Ljava/util/List;)Lgraphql/util/NodeMultiZipper;",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "withNewZipper",
+            "desc": "(Lgraphql/util/NodeZipper;)Lgraphql/util/NodeMultiZipper;",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "withReplacedZipper",
+            "desc": "(Lgraphql/util/NodeZipper;Lgraphql/util/NodeZipper;)Lgraphql/util/NodeMultiZipper;",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 5
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "withReplacedZipperForNode",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;)Lgraphql/util/NodeMultiZipper;",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 6
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDeepestZippers",
+            "desc": "(Ljava/util/Set;)Ljava/util/List;",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "moveUp",
+            "desc": "(Ljava/lang/Object;Ljava/util/List;)Lgraphql/util/NodeZipper;",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 27,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "zipperWithSameParent",
+            "desc": "(Ljava/util/List;)Ljava/util/Map;",
+            "line": 194,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$moveUp$0",
+            "desc": "(Lgraphql/util/NodeZipper;Lgraphql/util/NodeZipper;)I",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getDeepestZippers$0",
+            "desc": "(Lgraphql/util/NodeZipper;)Ljava/lang/Integer;",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withReplacedZipperForNode$0",
+            "desc": "(Ljava/lang/Object;Lgraphql/util/NodeZipper;)Z",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$getZipperForNode$0",
+            "desc": "(Ljava/lang/Object;Lgraphql/util/NodeZipper;)Z",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.CyclicSchemaAnalyzer$SchemaCycle": {
+        "line": {
+          "covered": 4,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;)V",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "size",
+            "desc": "()I",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getCycle",
+            "desc": "()Ljava/util/List;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.IdGenerator": {
+        "line": {
+          "covered": 17,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "uuid",
+            "desc": "()Ljava/util/UUID;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "generateId",
+            "desc": "()Ljava/util/UUID;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.FpKit$ArrayIterator": {
+        "line": {
+          "covered": 8,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 1
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 209,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasNext",
+            "desc": "()Z",
+            "line": 217,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "next",
+            "desc": "()Ljava/lang/Object;",
+            "line": 223,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.FpKit": {
+        "line": {
+          "covered": 98,
+          "missed": 15
+        },
+        "branch": {
+          "covered": 61,
+          "missed": 9
+        },
+        "method": {
+          "covered": 34,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getByName",
+            "desc": "(Ljava/util/List;Ljava/util/function/Function;Ljava/util/function/BinaryOperator;)Ljava/util/Map;",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toMap",
+            "desc": "(Ljava/util/Collection;Ljava/util/function/Function;Ljava/util/function/BinaryOperator;)Ljava/util/Map;",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "groupingBy",
+            "desc": "(Ljava/util/Collection;Ljava/util/function/Function;)Ljava/util/Map;",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filterAndGroupingBy",
+            "desc": "(Ljava/util/Collection;Ljava/util/function/Predicate;Ljava/util/function/Function;)Ljava/util/Map;",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toMapByUniqueKey",
+            "desc": "(Ljava/util/Collection;Ljava/util/function/Function;)Ljava/util/Map;",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "throwingMerger",
+            "desc": "()Ljava/util/function/BinaryOperator;",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getByName",
+            "desc": "(Ljava/util/List;Ljava/util/function/Function;)Ljava/util/Map;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mergeFirst",
+            "desc": "()Ljava/util/function/BinaryOperator;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toCollection",
+            "desc": "(Ljava/lang/Object;)Ljava/util/Collection;",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "arrayListSizedTo",
+            "desc": "(Ljava/util/Collection;)Ljava/util/List;",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toListOrSingletonList",
+            "desc": "(Ljava/lang/Object;)Ljava/util/List;",
+            "line": 168,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isIterable",
+            "desc": "(Ljava/lang/Object;)Z",
+            "line": 178,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toIterable",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Iterable;",
+            "line": 184,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toSize",
+            "desc": "(Ljava/lang/Object;)Ljava/util/OptionalInt;",
+            "line": 232,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "concat",
+            "desc": "(Ljava/util/List;Ljava/lang/Object;)Ljava/util/List;",
+            "line": 253,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "concat",
+            "desc": "(Ljava/util/List;Ljava/util/List;)Ljava/util/List;",
+            "line": 269,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "valuesToList",
+            "desc": "(Ljava/util/Map;)Ljava/util/List;",
+            "line": 278,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transposeMatrix",
+            "desc": "(Ljava/util/List;)Ljava/util/List;",
+            "line": 282,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 10
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 6
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "findOne",
+            "desc": "(Ljava/util/Collection;Ljava/util/function/Predicate;)Ljava/util/Optional;",
+            "line": 298,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "findOneOrNull",
+            "desc": "(Ljava/util/List;Ljava/util/function/Predicate;)Ljava/lang/Object;",
+            "line": 307,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "findIndex",
+            "desc": "(Ljava/util/List;Ljava/util/function/Predicate;)I",
+            "line": 311,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filterList",
+            "desc": "(Ljava/util/Collection;Ljava/util/function/Predicate;)Ljava/util/List;",
+            "line": 320,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filterSet",
+            "desc": "(Ljava/util/Collection;Ljava/util/function/Predicate;)Ljava/util/Set;",
+            "line": 330,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newList",
+            "desc": "()Ljava/util/function/Function;",
+            "line": 348,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "intraThreadMemoize",
+            "desc": "(Ljava/util/function/Supplier;)Ljava/util/function/Supplier;",
+            "line": 363,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "interThreadMemoize",
+            "desc": "(Ljava/util/function/Supplier;)Ljava/util/function/Supplier;",
+            "line": 377,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "intersection",
+            "desc": "(Ljava/util/Set;Ljava/util/Set;)Ljava/util/Set;",
+            "line": 392,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$newList$0",
+            "desc": "(Ljava/lang/Object;)Ljava/util/List;",
+            "line": 348,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$toIterable$1",
+            "desc": "(Ljava/lang/Object;)Ljava/util/Iterator;",
+            "line": 197,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$toIterable$0",
+            "desc": "(Ljava/lang/Object;)Ljava/util/Iterator;",
+            "line": 193,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$mergeFirst$0",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$1",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$0",
+            "desc": "(Ljava/lang/Object;)Z",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$filterAndGroupingBy$1",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$filterAndGroupingBy$0",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.TraverserState": {
+        "line": {
+          "covered": 17,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 11,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newQueueState",
+            "desc": "(Ljava/lang/Object;)Lgraphql/util/TraverserState;",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newStackState",
+            "desc": "(Ljava/lang/Object;)Lgraphql/util/TraverserState;",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "pop",
+            "desc": "()Ljava/lang/Object;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addNewContexts",
+            "desc": "(Ljava/util/Collection;Lgraphql/util/TraverserContext;)V",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEmpty",
+            "desc": "()Z",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addVisited",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newRootContext",
+            "desc": "(Ljava/util/Map;)Lgraphql/util/DefaultTraverserContext;",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newContext",
+            "desc": "(Ljava/lang/Object;Lgraphql/util/TraverserContext;Lgraphql/util/NodeLocation;)Lgraphql/util/DefaultTraverserContext;",
+            "line": 134,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newContextImpl",
+            "desc": "(Ljava/lang/Object;Lgraphql/util/TraverserContext;Ljava/util/Map;Lgraphql/util/NodeLocation;Z)Lgraphql/util/DefaultTraverserContext;",
+            "line": 142,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$addNewContexts$0",
+            "desc": "(Lgraphql/util/TraverserContext;Ljava/lang/Object;)Lgraphql/util/DefaultTraverserContext;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.TraverserState$StackTraverserState": {
+        "line": {
+          "covered": 20,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "pushAll",
+            "desc": "(Lgraphql/util/TraverserContext;Ljava/util/function/Function;)V",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$pushAll$0",
+            "desc": "(Ljava/util/Map;Lgraphql/util/TraverserContext;Ljava/util/Map;Ljava/lang/String;)V",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$pushAll$1",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.TreeTransformer": {
+        "line": {
+          "covered": 12,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/util/NodeAdapter;)V",
+            "line": 18,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/lang/Object;Lgraphql/util/TraverserVisitor;)Ljava/lang/Object;",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/lang/Object;Lgraphql/util/TraverserVisitor;Ljava/util/Map;)Ljava/lang/Object;",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.Interning": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "intern",
+            "desc": "(Ljava/lang/String;)Ljava/lang/String;",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.MutableRef": {
+        "line": {
+          "covered": 1,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 13,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.TreeParallelTransformer": {
+        "line": {
+          "covered": 35,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 11,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Object;Ljava/util/concurrent/ForkJoinPool;Lgraphql/util/NodeAdapter;)V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parallelTransformer",
+            "desc": "(Lgraphql/util/NodeAdapter;)Lgraphql/util/TreeParallelTransformer;",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parallelTransformer",
+            "desc": "(Lgraphql/util/NodeAdapter;Ljava/util/concurrent/ForkJoinPool;)Lgraphql/util/TreeParallelTransformer;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "rootVars",
+            "desc": "(Ljava/util/Map;)Lgraphql/util/TreeParallelTransformer;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "rootVar",
+            "desc": "(Ljava/lang/Class;Ljava/lang/Object;)Lgraphql/util/TreeParallelTransformer;",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/lang/Object;Lgraphql/util/TraverserVisitor;)Ljava/lang/Object;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newRootContext",
+            "desc": "(Ljava/util/Map;)Lgraphql/util/DefaultTraverserContext;",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transformImpl",
+            "desc": "(Ljava/lang/Object;Lgraphql/util/TraverserVisitor;)Ljava/lang/Object;",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "pushAll",
+            "desc": "(Lgraphql/util/TraverserContext;)Ljava/util/List;",
+            "line": 217,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newContext",
+            "desc": "(Ljava/lang/Object;Lgraphql/util/TraverserContext;Lgraphql/util/NodeLocation;)Lgraphql/util/DefaultTraverserContext;",
+            "line": 239,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newContextImpl",
+            "desc": "(Ljava/lang/Object;Lgraphql/util/TraverserContext;Ljava/util/Map;Lgraphql/util/NodeLocation;Z)Lgraphql/util/DefaultTraverserContext;",
+            "line": 247,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$pushAll$0",
+            "desc": "(Ljava/util/Map;Lgraphql/util/TraverserContext;Ljava/util/LinkedList;Ljava/util/Map;Ljava/lang/String;)V",
+            "line": 224,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$pushAll$1",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 230,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.Traverser": {
+        "line": {
+          "covered": 71,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 13,
+          "missed": 2
+        },
+        "method": {
+          "covered": 16,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/util/TraverserState;Ljava/util/function/Function;Ljava/lang/Object;)V",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "wrapListFunction",
+            "desc": "(Ljava/util/function/Function;)Ljava/util/function/Function;",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "rootVars",
+            "desc": "(Ljava/util/Map;)Lgraphql/util/Traverser;",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "rootVar",
+            "desc": "(Ljava/lang/Class;Ljava/lang/Object;)Lgraphql/util/Traverser;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "depthFirst",
+            "desc": "(Ljava/util/function/Function;)Lgraphql/util/Traverser;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "depthFirst",
+            "desc": "(Ljava/util/function/Function;Ljava/lang/Object;)Lgraphql/util/Traverser;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "depthFirst",
+            "desc": "(Ljava/util/function/Function;Ljava/lang/Object;Ljava/lang/Object;)Lgraphql/util/Traverser;",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "depthFirstWithNamedChildren",
+            "desc": "(Ljava/util/function/Function;Ljava/lang/Object;Ljava/lang/Object;)Lgraphql/util/Traverser;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "breadthFirst",
+            "desc": "(Ljava/util/function/Function;)Lgraphql/util/Traverser;",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "breadthFirst",
+            "desc": "(Ljava/util/function/Function;Ljava/lang/Object;)Lgraphql/util/Traverser;",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "breadthFirst",
+            "desc": "(Ljava/util/function/Function;Ljava/lang/Object;Ljava/lang/Object;)Lgraphql/util/Traverser;",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "breadthFirstWithNamedChildren",
+            "desc": "(Ljava/util/function/Function;Ljava/lang/Object;Ljava/lang/Object;)Lgraphql/util/Traverser;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "traverse",
+            "desc": "(Ljava/lang/Object;Lgraphql/util/TraverserVisitor;)Lgraphql/util/TraverserResult;",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "traverse",
+            "desc": "(Ljava/util/Collection;Lgraphql/util/TraverserVisitor;)Lgraphql/util/TraverserResult;",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 46,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 13,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$wrapListFunction$0",
+            "desc": "(Ljava/util/function/Function;Ljava/lang/Object;)Ljava/util/Map;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.NodeZipper": {
+        "line": {
+          "covered": 50,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 15,
+          "missed": 2
+        },
+        "method": {
+          "covered": 12,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Object;Ljava/util/List;Lgraphql/util/NodeAdapter;)V",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Object;Ljava/util/List;Lgraphql/util/NodeAdapter;Lgraphql/util/NodeZipper$ModificationType;)V",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getModificationType",
+            "desc": "()Lgraphql/util/NodeZipper$ModificationType;",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCurNode",
+            "desc": "()Ljava/lang/Object;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getBreadcrumbs",
+            "desc": "()Ljava/util/List;",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParent",
+            "desc": "()Ljava/lang/Object;",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "rootZipper",
+            "desc": "(Ljava/lang/Object;Lgraphql/util/NodeAdapter;)Lgraphql/util/NodeZipper;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "modifyNode",
+            "desc": "(Ljava/util/function/Function;)Lgraphql/util/NodeZipper;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deleteNode",
+            "desc": "()Lgraphql/util/NodeZipper;",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "insertAfter",
+            "desc": "(Ljava/lang/Object;)Lgraphql/util/NodeZipper;",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "insertBefore",
+            "desc": "(Ljava/lang/Object;)Lgraphql/util/NodeZipper;",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewNode",
+            "desc": "(Ljava/lang/Object;)Lgraphql/util/NodeZipper;",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "moveUp",
+            "desc": "()Lgraphql/util/NodeZipper;",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toRoot",
+            "desc": "()Ljava/lang/Object;",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 33,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 15,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 144,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.CyclicSchemaAnalyzer$GraphAndIndex": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/diffing/SchemaGraph;I)V",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.Anonymizer$2": {
+        "line": {
+          "covered": 79,
+          "missed": 11
+        },
+        "branch": {
+          "covered": 28,
+          "missed": 8
+        },
+        "method": {
+          "covered": 14,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/function/BiConsumer;Ljava/util/concurrent/atomic/AtomicInteger;Ljava/util/Map;Ljava/util/Map;Lgraphql/schema/GraphQLSchema;Ljava/util/function/Consumer;Ljava/util/concurrent/atomic/AtomicInteger;Ljava/util/concurrent/atomic/AtomicInteger;Ljava/util/concurrent/atomic/AtomicInteger;Ljava/util/concurrent/atomic/AtomicInteger;Ljava/util/concurrent/atomic/AtomicInteger;Ljava/util/concurrent/atomic/AtomicInteger;Ljava/util/concurrent/atomic/AtomicInteger;Ljava/util/concurrent/atomic/AtomicInteger;Ljava/util/concurrent/atomic/AtomicInteger;)V",
+            "line": 464,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLArgument",
+            "desc": "(Lgraphql/schema/GraphQLArgument;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 467,
+            "counters": {
+              "line": {
+                "covered": 23,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLAppliedDirectiveArgument",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirectiveArgument;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 510,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 521,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLAppliedDirective",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirective;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 530,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInterfaceType",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 540,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLEnumType",
+            "desc": "(Lgraphql/schema/GraphQLEnumType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 550,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLEnumValueDefinition",
+            "desc": "(Lgraphql/schema/GraphQLEnumValueDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 560,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 567,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputObjectField",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 589,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputObjectType",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 597,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLObjectType",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 608,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLScalarType",
+            "desc": "(Lgraphql/schema/GraphQLScalarType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 618,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLUnionType",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 628,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.Anonymizer$1": {
+        "line": {
+          "covered": 115,
+          "missed": 10
+        },
+        "branch": {
+          "covered": 25,
+          "missed": 7
+        },
+        "method": {
+          "covered": 29,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Ljava/util/Map;Ljava/util/Map;Ljava/util/concurrent/atomic/AtomicInteger;Ljava/util/concurrent/atomic/AtomicInteger;)V",
+            "line": 164,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLTypeReference",
+            "desc": "(Lgraphql/schema/GraphQLTypeReference;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 168,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLArgument",
+            "desc": "(Lgraphql/schema/GraphQLArgument;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 176,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLAppliedDirectiveArgument",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirectiveArgument;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 205,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInterfaceType",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 219,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLEnumType",
+            "desc": "(Lgraphql/schema/GraphQLEnumType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 234,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLEnumValueDefinition",
+            "desc": "(Lgraphql/schema/GraphQLEnumValueDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 246,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 255,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 264,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLAppliedDirective",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirective;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 276,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputObjectField",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 299,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputObjectType",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 321,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLObjectType",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 334,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLScalarType",
+            "desc": "(Lgraphql/schema/GraphQLScalarType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 346,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLUnionType",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 358,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLUnionType$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLUnionType$Builder;)V",
+            "line": 363,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLScalarType$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLScalarType$Builder;)V",
+            "line": 351,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLObjectType$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLObjectType$Builder;)V",
+            "line": 339,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLInputObjectType$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLInputObjectType$Builder;)V",
+            "line": 326,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLInputObjectField$0",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Value;Lgraphql/schema/GraphQLInputObjectField$Builder;)V",
+            "line": 309,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLAppliedDirective$1",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLAppliedDirective$Builder;)V",
+            "line": 292,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLAppliedDirective$0",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirectiveArgument;Lgraphql/schema/GraphQLAppliedDirective$Builder;)V",
+            "line": 282,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLDirective$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLDirective$Builder;)V",
+            "line": 269,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLFieldDefinition$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLFieldDefinition$Builder;)V",
+            "line": 257,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLEnumValueDefinition$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLEnumValueDefinition$Builder;)V",
+            "line": 248,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLEnumType$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLEnumType$Builder;)V",
+            "line": 239,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLInterfaceType$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLInterfaceType$Builder;)V",
+            "line": 224,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLAppliedDirectiveArgument$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLAppliedDirectiveArgument;Ljava/util/Map;Ljava/util/concurrent/atomic/AtomicInteger;Ljava/util/concurrent/atomic/AtomicInteger;Lgraphql/schema/GraphQLAppliedDirectiveArgument$Builder;)V",
+            "line": 208,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLArgument$1",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLArgument;Ljava/util/Map;Ljava/util/concurrent/atomic/AtomicInteger;Ljava/util/concurrent/atomic/AtomicInteger;Lgraphql/schema/GraphQLArgument$Builder;)V",
+            "line": 187,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLArgument$0",
+            "desc": "(Lgraphql/schema/GraphQLArgument$Builder;)V",
+            "line": 182,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.Anonymizer$4": {
+        "line": {
+          "covered": 55,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 14,
+          "missed": 0
+        },
+        "method": {
+          "covered": 19,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Map;Lgraphql/schema/GraphQLSchema;Ljava/util/concurrent/atomic/AtomicInteger;Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;Ljava/util/concurrent/atomic/AtomicInteger;Ljava/util/concurrent/atomic/AtomicInteger;)V",
+            "line": 796,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitDirective",
+            "desc": "(Lgraphql/language/Directive;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 800,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitOperationDefinition",
+            "desc": "(Lgraphql/language/OperationDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 808,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitField",
+            "desc": "(Lgraphql/language/Field;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 817,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitVariableDefinition",
+            "desc": "(Lgraphql/language/VariableDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 834,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitVariableReference",
+            "desc": "(Lgraphql/language/VariableReference;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 859,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitFragmentDefinition",
+            "desc": "(Lgraphql/language/FragmentDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 865,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitInlineFragment",
+            "desc": "(Lgraphql/language/InlineFragment;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 873,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitFragmentSpread",
+            "desc": "(Lgraphql/language/FragmentSpread;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 884,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitArgument",
+            "desc": "(Lgraphql/language/Argument;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 892,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitArgument$0",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Value;Lgraphql/language/Argument$Builder;)V",
+            "line": 902,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitFragmentSpread$0",
+            "desc": "(Ljava/lang/String;Lgraphql/language/FragmentSpread$Builder;)V",
+            "line": 885,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitInlineFragment$0",
+            "desc": "(Ljava/lang/String;Lgraphql/language/InlineFragment$Builder;)V",
+            "line": 877,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitFragmentDefinition$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Lgraphql/language/FragmentDefinition$Builder;)V",
+            "line": 868,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitVariableReference$0",
+            "desc": "(Ljava/lang/String;Lgraphql/language/VariableReference$Builder;)V",
+            "line": 860,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitVariableDefinition$0",
+            "desc": "(Ljava/lang/String;Lgraphql/language/VariableDefinition;Lgraphql/schema/GraphQLSchema;Ljava/util/Map;Ljava/util/concurrent/atomic/AtomicInteger;Ljava/util/concurrent/atomic/AtomicInteger;Lgraphql/language/VariableDefinition$Builder;)V",
+            "line": 836,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitField$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Lgraphql/language/Field$Builder;)V",
+            "line": 829,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitOperationDefinition$0",
+            "desc": "(Lgraphql/language/OperationDefinition$Builder;)V",
+            "line": 809,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitDirective$0",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Directive$Builder;)V",
+            "line": 803,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.Anonymizer$3": {
+        "line": {
+          "covered": 45,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 16,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;Lgraphql/schema/GraphQLSchema;Ljava/util/Map;Ljava/util/concurrent/atomic/AtomicInteger;Ljava/util/concurrent/atomic/AtomicInteger;)V",
+            "line": 714,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitField",
+            "desc": "(Lgraphql/analysis/QueryVisitorFieldEnvironment;)V",
+            "line": 718,
+            "counters": {
+              "line": {
+                "covered": 20,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitDirectiveArgumentValues",
+            "desc": "(Lgraphql/language/Directive;Lgraphql/language/Value;)V",
+            "line": 744,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitInlineFragment",
+            "desc": "(Lgraphql/analysis/QueryVisitorInlineFragmentEnvironment;)V",
+            "line": 755,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitArgumentValue",
+            "desc": "(Lgraphql/analysis/QueryVisitorFieldArgumentValueEnvironment;)Lgraphql/util/TraversalControl;",
+            "line": 759,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitFragmentSpread",
+            "desc": "(Lgraphql/analysis/QueryVisitorFragmentSpreadEnvironment;)V",
+            "line": 772,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitArgument",
+            "desc": "(Lgraphql/analysis/QueryVisitorFieldArgumentEnvironment;)Lgraphql/util/TraversalControl;",
+            "line": 785,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.util.DefaultTraverserContext": {
+        "line": {
+          "covered": 76,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 18,
+          "missed": 2
+        },
+        "method": {
+          "covered": 28,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Object;Lgraphql/util/TraverserContext;Ljava/util/Set;Ljava/util/Map;Ljava/lang/Object;Lgraphql/util/NodeLocation;ZZ)V",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "dummy",
+            "desc": "()Lgraphql/util/DefaultTraverserContext;",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "simple",
+            "desc": "(Ljava/lang/Object;)Lgraphql/util/DefaultTraverserContext;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "thisNode",
+            "desc": "()Ljava/lang/Object;",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "originalThisNode",
+            "desc": "()Ljava/lang/Object;",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "changeNode",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deleteNode",
+            "desc": "()V",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isDeleted",
+            "desc": "()Z",
+            "line": 106,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isChanged",
+            "desc": "()Z",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParentContext",
+            "desc": "()Lgraphql/util/TraverserContext;",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParentNodes",
+            "desc": "()Ljava/util/List;",
+            "line": 122,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getBreadcrumbs",
+            "desc": "()Ljava/util/List;",
+            "line": 133,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParentNode",
+            "desc": "()Ljava/lang/Object;",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitedNodes",
+            "desc": "()Ljava/util/Set;",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isVisited",
+            "desc": "()Z",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getVar",
+            "desc": "(Ljava/lang/Class;)Ljava/lang/Object;",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setVar",
+            "desc": "(Ljava/lang/Class;Ljava/lang/Object;)Lgraphql/util/TraverserContext;",
+            "line": 161,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setAccumulate",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 167,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewAccumulate",
+            "desc": "()Ljava/lang/Object;",
+            "line": 173,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCurrentAccumulate",
+            "desc": "()Ljava/lang/Object;",
+            "line": 182,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSharedContextData",
+            "desc": "()Ljava/lang/Object;",
+            "line": 188,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setCurAccValue",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 195,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocation",
+            "desc": "()Lgraphql/util/NodeLocation;",
+            "line": 201,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isRootContext",
+            "desc": "()Z",
+            "line": 206,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getVarFromParents",
+            "desc": "(Ljava/lang/Class;)Ljava/lang/Object;",
+            "line": 211,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setChildrenContexts",
+            "desc": "(Ljava/util/Map;)V",
+            "line": 226,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildrenContexts",
+            "desc": "()Ljava/util/Map;",
+            "line": 233,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setPhase",
+            "desc": "(Lgraphql/util/TraverserContext$Phase;)V",
+            "line": 241,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPhase",
+            "desc": "()Lgraphql/util/TraverserContext$Phase;",
+            "line": 246,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isParallel",
+            "desc": "()Z",
+            "line": 251,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.incremental.IncrementalExecutionResultImpl": {
+        "line": {
+          "covered": 23,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 9,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/incremental/IncrementalExecutionResultImpl$Builder;)V",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasNext",
+            "desc": "()Z",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getIncremental",
+            "desc": "()Ljava/util/List;",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getIncrementalItemPublisher",
+            "desc": "()Lorg/reactivestreams/Publisher;",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newIncrementalExecutionResult",
+            "desc": "()Lgraphql/incremental/IncrementalExecutionResultImpl$Builder;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fromExecutionResult",
+            "desc": "(Lgraphql/ExecutionResult;)Lgraphql/incremental/IncrementalExecutionResultImpl$Builder;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fromIncrementalExecutionResult",
+            "desc": "(Lgraphql/incremental/IncrementalExecutionResult;)Lgraphql/incremental/IncrementalExecutionResultImpl$Builder;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/incremental/IncrementalExecutionResult;",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toSpecification",
+            "desc": "()Ljava/util/Map;",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.incremental.IncrementalPayload": {
+        "line": {
+          "covered": 20,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 9,
+          "missed": 1
+        },
+        "method": {
+          "covered": 3,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;Ljava/lang/String;Ljava/util/List;Ljava/util/Map;)V",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPath",
+            "desc": "()Ljava/util/List;",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getLabel",
+            "desc": "()Ljava/lang/String;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getErrors",
+            "desc": "()Ljava/util/List;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toSpecification",
+            "desc": "()Ljava/util/Map;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "errorsToSpec",
+            "desc": "(Ljava/util/List;)Ljava/lang/Object;",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.incremental.StreamPayload": {
+        "line": {
+          "covered": 7,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;Ljava/util/List;Ljava/lang/String;Ljava/util/List;Ljava/util/Map;)V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getItems",
+            "desc": "()Ljava/util/List;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toSpecification",
+            "desc": "()Ljava/util/Map;",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newStreamedItem",
+            "desc": "()Lgraphql/incremental/StreamPayload$Builder;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.incremental.IncrementalPayload$Builder": {
+        "line": {
+          "covered": 17,
+          "missed": 9
+        },
+        "branch": {
+          "covered": 1,
+          "missed": 5
+        },
+        "method": {
+          "covered": 8,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "from",
+            "desc": "(Lgraphql/incremental/IncrementalPayload;)Lgraphql/incremental/IncrementalPayload$Builder;",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 6
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "path",
+            "desc": "(Lgraphql/execution/ResultPath;)Lgraphql/incremental/IncrementalPayload$Builder;",
+            "line": 124,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "path",
+            "desc": "(Ljava/util/List;)Lgraphql/incremental/IncrementalPayload$Builder;",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "label",
+            "desc": "(Ljava/lang/String;)Lgraphql/incremental/IncrementalPayload$Builder;",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "errors",
+            "desc": "(Ljava/util/List;)Lgraphql/incremental/IncrementalPayload$Builder;",
+            "line": 141,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addErrors",
+            "desc": "(Ljava/util/List;)Lgraphql/incremental/IncrementalPayload$Builder;",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addError",
+            "desc": "(Lgraphql/GraphQLError;)Lgraphql/incremental/IncrementalPayload$Builder;",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "extensions",
+            "desc": "(Ljava/util/Map;)Lgraphql/incremental/IncrementalPayload$Builder;",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addExtension",
+            "desc": "(Ljava/lang/String;Ljava/lang/Object;)Lgraphql/incremental/IncrementalPayload$Builder;",
+            "line": 161,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.incremental.DeferPayload$Builder": {
+        "line": {
+          "covered": 5,
+          "missed": 7
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "data",
+            "desc": "(Ljava/lang/Object;)Lgraphql/incremental/DeferPayload$Builder;",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "from",
+            "desc": "(Lgraphql/incremental/DeferPayload;)Lgraphql/incremental/DeferPayload$Builder;",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "from",
+            "desc": "(Lgraphql/ExecutionResult;)Lgraphql/incremental/DeferPayload$Builder;",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/incremental/DeferPayload;",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.incremental.DeferPayload": {
+        "line": {
+          "covered": 8,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Object;Ljava/util/List;Ljava/lang/String;Ljava/util/List;Ljava/util/Map;)V",
+            "line": 21,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getData",
+            "desc": "()Ljava/lang/Object;",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toSpecification",
+            "desc": "()Ljava/util/Map;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newDeferredItem",
+            "desc": "()Lgraphql/incremental/DeferPayload$Builder;",
+            "line": 63,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.incremental.DelayedIncrementalPartialResultImpl$Builder": {
+        "line": {
+          "covered": 10,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasNext",
+            "desc": "(Z)Lgraphql/incremental/DelayedIncrementalPartialResultImpl$Builder;",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "incrementalItems",
+            "desc": "(Ljava/util/List;)Lgraphql/incremental/DelayedIncrementalPartialResultImpl$Builder;",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "extensions",
+            "desc": "(Ljava/util/Map;)Lgraphql/incremental/DelayedIncrementalPartialResultImpl$Builder;",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/incremental/DelayedIncrementalPartialResultImpl;",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.incremental.DelayedIncrementalPartialResultImpl": {
+        "line": {
+          "covered": 19,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 5,
+          "missed": 1
+        },
+        "method": {
+          "covered": 5,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/incremental/DelayedIncrementalPartialResultImpl$Builder;)V",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getIncremental",
+            "desc": "()Ljava/util/List;",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasNext",
+            "desc": "()Z",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toSpecification",
+            "desc": "()Ljava/util/Map;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newIncrementalExecutionResult",
+            "desc": "()Lgraphql/incremental/DelayedIncrementalPartialResultImpl$Builder;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.incremental.StreamPayload$Builder": {
+        "line": {
+          "covered": 5,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "items",
+            "desc": "(Ljava/util/List;)Lgraphql/incremental/StreamPayload$Builder;",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "from",
+            "desc": "(Lgraphql/incremental/StreamPayload;)Lgraphql/incremental/StreamPayload$Builder;",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/incremental/StreamPayload;",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.incremental.IncrementalExecutionResultImpl$Builder": {
+        "line": {
+          "covered": 14,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasNext",
+            "desc": "(Z)Lgraphql/incremental/IncrementalExecutionResultImpl$Builder;",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "incremental",
+            "desc": "(Ljava/util/List;)Lgraphql/incremental/IncrementalExecutionResultImpl$Builder;",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "incrementalItemPublisher",
+            "desc": "(Lorg/reactivestreams/Publisher;)Lgraphql/incremental/IncrementalExecutionResultImpl$Builder;",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "from",
+            "desc": "(Lgraphql/incremental/IncrementalExecutionResult;)Lgraphql/incremental/IncrementalExecutionResultImpl$Builder;",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/incremental/IncrementalExecutionResult;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLInputObjectType": {
+        "line": {
+          "covered": 52,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 29,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/util/List;Ljava/util/List;Lgraphql/language/InputObjectTypeDefinition;Ljava/util/List;)V",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildDefinitionMap",
+            "desc": "(Ljava/util/List;)Lcom/google/common/collect/ImmutableMap;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasOneOf",
+            "desc": "(Ljava/util/List;Ljava/util/List;)Z",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isOneOf",
+            "desc": "()Z",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDescription",
+            "desc": "()Ljava/lang/String;",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFields",
+            "desc": "()Ljava/util/List;",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getField",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLInputObjectField;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 122,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLDirective;",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllAppliedDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 142,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLAppliedDirective;",
+            "line": 147,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinition",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLInputObjectField;",
+            "line": 152,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinitions",
+            "desc": "()Ljava/util/List;",
+            "line": 157,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefinition",
+            "desc": "()Lgraphql/language/InputObjectTypeDefinition;",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExtensionDefinitions",
+            "desc": "()Ljava/util/List;",
+            "line": 166,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/schema/GraphQLInputObjectType;",
+            "line": 178,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "copy",
+            "desc": "()Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 185,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 191,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 196,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildrenWithTypeReferences",
+            "desc": "()Lgraphql/schema/SchemaElementChildrenContainer;",
+            "line": 204,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;)Lgraphql/schema/GraphQLInputObjectType;",
+            "line": 213,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 239,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newInputObject",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;)Lgraphql/schema/GraphQLInputObjectType$Builder;",
+            "line": 249,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newInputObject",
+            "desc": "()Lgraphql/schema/GraphQLInputObjectType$Builder;",
+            "line": 253,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;Lgraphql/schema/GraphQLInputObjectType$Builder;)V",
+            "line": 214,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$hasOneOf$1",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)Z",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$hasOneOf$0",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirective;)Z",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildDefinitionMap$0",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;Lgraphql/schema/GraphQLInputObjectField;)Lgraphql/schema/GraphQLInputObjectField;",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLDirectiveContainer": {
+        "line": {
+          "covered": 3,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "getAppliedDirectives",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasDirective",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasAppliedDirective",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLAppliedDirective": {
+        "line": {
+          "covered": 26,
+          "missed": 8
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 1
+        },
+        "method": {
+          "covered": 13,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Directive;Ljava/util/List;)V",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDescription",
+            "desc": "()Ljava/lang/String;",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArguments",
+            "desc": "()Ljava/util/List;",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgument",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLAppliedDirectiveArgument;",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefinition",
+            "desc": "()Lgraphql/language/Directive;",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 5
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/schema/GraphQLAppliedDirective;",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "copy",
+            "desc": "()Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 106,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildrenWithTypeReferences",
+            "desc": "()Lgraphql/schema/SchemaElementChildrenContainer;",
+            "line": 122,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;)Lgraphql/schema/GraphQLAppliedDirective;",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newDirective",
+            "desc": "()Lgraphql/schema/GraphQLAppliedDirective$Builder;",
+            "line": 152,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newDirective",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirective;)Lgraphql/schema/GraphQLAppliedDirective$Builder;",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;Lgraphql/schema/GraphQLAppliedDirective$Builder;)V",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphqlElementParentTree": {
+        "line": {
+          "covered": 18,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 5,
+          "missed": 1
+        },
+        "method": {
+          "covered": 4,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Deque;)V",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getElement",
+            "desc": "()Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParentInfo",
+            "desc": "()Ljava/util/Optional;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toList",
+            "desc": "()Ljava/util/List;",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.DataFetchingFieldSelectionSetImpl$1": {
+        "line": {
+          "covered": 2,
+          "missed": 7
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 7
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "contains",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "containsAnyOf",
+            "desc": "(Ljava/lang/String;[Ljava/lang/String;)Z",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "containsAllOf",
+            "desc": "(Ljava/lang/String;[Ljava/lang/String;)Z",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getFields",
+            "desc": "()Ljava/util/List;",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getImmediateFields",
+            "desc": "()Ljava/util/List;",
+            "line": 63,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getFields",
+            "desc": "(Ljava/lang/String;[Ljava/lang/String;)Ljava/util/List;",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getFieldsGroupedByResultKey",
+            "desc": "()Ljava/util/Map;",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getFieldsGroupedByResultKey",
+            "desc": "(Ljava/lang/String;[Ljava/lang/String;)Ljava/util/Map;",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.PropertyFetchingImpl$FastNoSuchMethodException": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 496,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fillInStackTrace",
+            "desc": "()Ljava/lang/Throwable;",
+            "line": 501,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.FieldCoordinates": {
+        "line": {
+          "covered": 20,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 6,
+          "missed": 0
+        },
+        "method": {
+          "covered": 11,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Z)V",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeName",
+            "desc": "()Ljava/lang/String;",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isSystemCoordinates",
+            "desc": "()Z",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertValidNames",
+            "desc": "()V",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "coordinates",
+            "desc": "(Lgraphql/schema/GraphQLFieldsContainer;Lgraphql/schema/GraphQLFieldDefinition;)Lgraphql/schema/FieldCoordinates;",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "coordinates",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/schema/FieldCoordinates;",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "coordinates",
+            "desc": "(Lgraphql/schema/GraphQLFieldsContainer;Ljava/lang/String;)Lgraphql/schema/FieldCoordinates;",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "systemCoordinates",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/FieldCoordinates;",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$assertValidNames$0",
+            "desc": "()Ljava/lang/String;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.SchemaTransformer$RelevantZippersAndBreadcrumbs": {
+        "line": {
+          "covered": 27,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 6,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;Ljava/util/Map;)V",
+            "line": 351,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isRelevantZipper",
+            "desc": "(Lgraphql/util/NodeZipper;)Z",
+            "line": 367,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "zippersWithParent",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;)Ljava/util/Collection;",
+            "line": 371,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "removeRelevantZipper",
+            "desc": "(Lgraphql/util/NodeZipper;)V",
+            "line": 375,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getBreadcrumbs",
+            "desc": "(Lgraphql/util/NodeZipper;)Ljava/util/List;",
+            "line": 379,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "updateZipper",
+            "desc": "(Lgraphql/util/NodeZipper;Lgraphql/util/NodeZipper;)V",
+            "line": 385,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.DataFetcherFactoryEnvironment$Builder": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;)Lgraphql/schema/DataFetcherFactoryEnvironment$Builder;",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/DataFetcherFactoryEnvironment;",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.SchemaTraverser$TraverserDelegateVisitor": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLTypeVisitor;)V",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enter",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "leave",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "backRef",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.DefaultGraphqlTypeComparatorRegistry": {
+        "line": {
+          "covered": 45,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 11,
+          "missed": 1
+        },
+        "method": {
+          "covered": 12,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "sensibleGroupedOrder",
+            "desc": "()Ljava/util/Comparator;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unwrapElement",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;)Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "compareByName",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;Lgraphql/schema/GraphQLSchemaElement;)I",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Map;)V",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getComparator",
+            "desc": "(Lgraphql/schema/GraphqlTypeComparatorEnvironment;)Ljava/util/Comparator;",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "defaultComparators",
+            "desc": "()Lgraphql/schema/GraphqlTypeComparatorRegistry;",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newComparators",
+            "desc": "()Lgraphql/schema/DefaultGraphqlTypeComparatorRegistry$Builder;",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getComparator$0",
+            "desc": "(Lgraphql/schema/GraphqlTypeComparatorEnvironment$Builder;)V",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$compareByName$0",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/String;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$sensibleGroupedOrder$0",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;Lgraphql/schema/GraphQLSchemaElement;)I",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.SchemaTraverser": {
+        "line": {
+          "covered": 25,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 9,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/function/Function;)V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "depthFirstFullSchema",
+            "desc": "(Lgraphql/schema/GraphQLTypeVisitor;Lgraphql/schema/GraphQLSchema;)Lgraphql/util/TraverserResult;",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "depthFirstFullSchema",
+            "desc": "(Ljava/util/List;Lgraphql/schema/GraphQLSchema;Ljava/util/Map;)Lgraphql/util/TraverserResult;",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "depthFirst",
+            "desc": "(Lgraphql/schema/GraphQLTypeVisitor;Lgraphql/schema/GraphQLSchemaElement;)Lgraphql/util/TraverserResult;",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "depthFirst",
+            "desc": "(Lgraphql/schema/GraphQLTypeVisitor;Ljava/util/Collection;)Lgraphql/util/TraverserResult;",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "depthFirst",
+            "desc": "(Lgraphql/util/Traverser;Lgraphql/util/TraverserVisitor;Ljava/util/Collection;)Lgraphql/util/TraverserResult;",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "initTraverser",
+            "desc": "()Lgraphql/util/Traverser;",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "doTraverse",
+            "desc": "(Lgraphql/util/Traverser;Ljava/util/Collection;Lgraphql/util/TraverserVisitor;)Lgraphql/util/TraverserResult;",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.DefaultGraphqlTypeComparatorRegistry$Builder": {
+        "line": {
+          "covered": 11,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addComparator",
+            "desc": "(Lgraphql/schema/GraphqlTypeComparatorEnvironment;Ljava/lang/Class;Ljava/util/Comparator;)Lgraphql/schema/DefaultGraphqlTypeComparatorRegistry$Builder;",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addComparator",
+            "desc": "(Ljava/util/function/UnaryOperator;Ljava/lang/Class;Ljava/util/Comparator;)Lgraphql/schema/DefaultGraphqlTypeComparatorRegistry$Builder;",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/DefaultGraphqlTypeComparatorRegistry;",
+            "line": 160,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphqlTypeComparatorEnvironment": {
+        "line": {
+          "covered": 11,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Class;Ljava/lang/Class;)V",
+            "line": 21,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParentType",
+            "desc": "()Ljava/lang/Class;",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getElementType",
+            "desc": "()Ljava/lang/Class;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/schema/GraphqlTypeComparatorEnvironment;",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newEnvironment",
+            "desc": "()Lgraphql/schema/GraphqlTypeComparatorEnvironment$Builder;",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newEnvironment",
+            "desc": "(Lgraphql/schema/GraphqlTypeComparatorEnvironment;)Lgraphql/schema/GraphqlTypeComparatorEnvironment$Builder;",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLInterfaceType$Builder": {
+        "line": {
+          "covered": 61,
+          "missed": 12
+        },
+        "branch": {
+          "covered": 5,
+          "missed": 7
+        },
+        "method": {
+          "covered": 20,
+          "missed": 6
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 266,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;)V",
+            "line": 266,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "definition",
+            "desc": "(Lgraphql/language/InterfaceTypeDefinition;)Lgraphql/schema/GraphQLInterfaceType$Builder;",
+            "line": 285,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "extensionDefinitions",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLInterfaceType$Builder;",
+            "line": 290,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "field",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;)Lgraphql/schema/GraphQLInterfaceType$Builder;",
+            "line": 295,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "field",
+            "desc": "(Ljava/util/function/UnaryOperator;)Lgraphql/schema/GraphQLInterfaceType$Builder;",
+            "line": 314,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "field",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition$Builder;)Lgraphql/schema/GraphQLInterfaceType$Builder;",
+            "line": 329,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fields",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLInterfaceType$Builder;",
+            "line": 333,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceFields",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLInterfaceType$Builder;",
+            "line": 339,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasField",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 346,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clearFields",
+            "desc": "()Lgraphql/schema/GraphQLInterfaceType$Builder;",
+            "line": 355,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "typeResolver",
+            "desc": "(Lgraphql/schema/TypeResolver;)Lgraphql/schema/GraphQLInterfaceType$Builder;",
+            "line": 368,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceInterfaces",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLInterfaceType$Builder;",
+            "line": 373,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "replaceInterfacesOrReferences",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLInterfaceType$Builder;",
+            "line": 377,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withInterface",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;)Lgraphql/schema/GraphQLInterfaceType$Builder;",
+            "line": 390,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withInterface",
+            "desc": "(Lgraphql/schema/GraphQLTypeReference;)Lgraphql/schema/GraphQLInterfaceType$Builder;",
+            "line": 396,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withInterfaces",
+            "desc": "([Lgraphql/schema/GraphQLInterfaceType;)Lgraphql/schema/GraphQLInterfaceType$Builder;",
+            "line": 402,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "withInterfaces",
+            "desc": "([Lgraphql/schema/GraphQLTypeReference;)Lgraphql/schema/GraphQLInterfaceType$Builder;",
+            "line": 409,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "replaceDirectives",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLInterfaceType$Builder;",
+            "line": 420,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withDirectives",
+            "desc": "([Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLInterfaceType$Builder;",
+            "line": 425,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "withDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLInterfaceType$Builder;",
+            "line": 430,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective$Builder;)Lgraphql/schema/GraphQLInterfaceType$Builder;",
+            "line": 435,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "clearDirectives",
+            "desc": "()Lgraphql/schema/GraphQLInterfaceType$Builder;",
+            "line": 440,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLInterfaceType$Builder;",
+            "line": 445,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLInterfaceType$Builder;",
+            "line": 450,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/GraphQLInterfaceType;",
+            "line": 454,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLUnionType": {
+        "line": {
+          "covered": 54,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 6,
+          "missed": 0
+        },
+        "method": {
+          "covered": 24,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Lgraphql/schema/TypeResolver;Ljava/util/List;Ljava/util/List;Lgraphql/language/UnionTypeDefinition;Ljava/util/List;)V",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceTypes",
+            "desc": "(Ljava/util/List;)V",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypes",
+            "desc": "()Ljava/util/List;",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isPossibleType",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;)Z",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeResolver",
+            "desc": "()Lgraphql/schema/TypeResolver;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDescription",
+            "desc": "()Ljava/lang/String;",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefinition",
+            "desc": "()Lgraphql/language/UnionTypeDefinition;",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExtensionDefinitions",
+            "desc": "()Ljava/util/List;",
+            "line": 133,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 143,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 148,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLDirective;",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 158,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllAppliedDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLAppliedDirective;",
+            "line": 168,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/schema/GraphQLUnionType;",
+            "line": 180,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "copy",
+            "desc": "()Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 187,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 193,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 198,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildrenWithTypeReferences",
+            "desc": "()Lgraphql/schema/SchemaElementChildrenContainer;",
+            "line": 206,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;)Lgraphql/schema/GraphQLUnionType;",
+            "line": 215,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 241,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newUnionType",
+            "desc": "()Lgraphql/schema/GraphQLUnionType$Builder;",
+            "line": 249,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newUnionType",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;)Lgraphql/schema/GraphQLUnionType$Builder;",
+            "line": 253,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;Lgraphql/schema/GraphQLUnionType$Builder;)V",
+            "line": 216,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLEnumValueDefinition$Builder": {
+        "line": {
+          "covered": 23,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 11,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 203,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLEnumValueDefinition;)V",
+            "line": 206,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "value",
+            "desc": "(Ljava/lang/Object;)Lgraphql/schema/GraphQLEnumValueDefinition$Builder;",
+            "line": 215,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deprecationReason",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLEnumValueDefinition$Builder;",
+            "line": 220,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "definition",
+            "desc": "(Lgraphql/language/EnumValueDefinition;)Lgraphql/schema/GraphQLEnumValueDefinition$Builder;",
+            "line": 225,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceDirectives",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLEnumValueDefinition$Builder;",
+            "line": 233,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withDirectives",
+            "desc": "([Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLEnumValueDefinition$Builder;",
+            "line": 238,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "withDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLEnumValueDefinition$Builder;",
+            "line": 243,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective$Builder;)Lgraphql/schema/GraphQLEnumValueDefinition$Builder;",
+            "line": 248,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "clearDirectives",
+            "desc": "()Lgraphql/schema/GraphQLEnumValueDefinition$Builder;",
+            "line": 253,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLEnumValueDefinition$Builder;",
+            "line": 258,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLEnumValueDefinition$Builder;",
+            "line": 263,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/GraphQLEnumValueDefinition;",
+            "line": 267,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLSchemaElementAdapter": {
+        "line": {
+          "covered": 4,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "getNamedChildren",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;)Ljava/util/Map;",
+            "line": 21,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;Ljava/util/Map;)Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "removeChild",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;Lgraphql/util/NodeLocation;)Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$removeChild$0",
+            "desc": "(Lgraphql/util/NodeLocation;Lgraphql/schema/SchemaElementChildrenContainer$Builder;)V",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 13,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.DataFetcherFactoryEnvironment": {
+        "line": {
+          "covered": 4,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;)V",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinition",
+            "desc": "()Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "newDataFetchingFactoryEnvironment",
+            "desc": "()Lgraphql/schema/DataFetcherFactoryEnvironment$Builder;",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLNonNull": {
+        "line": {
+          "covered": 28,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 9,
+          "missed": 3
+        },
+        "method": {
+          "covered": 13,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "nonNull",
+            "desc": "(Lgraphql/schema/GraphQLType;)Lgraphql/schema/GraphQLNonNull;",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLType;)V",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertNonNullWrapping",
+            "desc": "(Lgraphql/schema/GraphQLType;)V",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getWrappedType",
+            "desc": "()Lgraphql/schema/GraphQLType;",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOriginalWrappedType",
+            "desc": "()Lgraphql/schema/GraphQLType;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "replaceType",
+            "desc": "(Lgraphql/schema/GraphQLType;)V",
+            "line": 63,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Ljava/lang/Object;)Z",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildrenWithTypeReferences",
+            "desc": "()Lgraphql/schema/SchemaElementChildrenContainer;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;)Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "copy",
+            "desc": "()Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$assertNonNullWrapping$0",
+            "desc": "()Ljava/lang/String;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.SingletonPropertyDataFetcher$1": {
+        "line": {
+          "covered": 2,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 18,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "get",
+            "desc": "(Lgraphql/schema/DataFetcherFactoryEnvironment;)Lgraphql/schema/DataFetcher;",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "get",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;)Lgraphql/schema/DataFetcher;",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.CoercingParseLiteralException$Builder": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/CoercingParseLiteralException;",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphqlDirectivesContainerTypeBuilder": {
+        "line": {
+          "covered": 29,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 2
+        },
+        "method": {
+          "covered": 9,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 11,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceAppliedDirectives",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphqlDirectivesContainerTypeBuilder;",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withAppliedDirectives",
+            "desc": "([Lgraphql/schema/GraphQLAppliedDirective;)Lgraphql/schema/GraphqlDirectivesContainerTypeBuilder;",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withAppliedDirective",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirective;)Lgraphql/schema/GraphqlDirectivesContainerTypeBuilder;",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withAppliedDirective",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirective$Builder;)Lgraphql/schema/GraphqlDirectivesContainerTypeBuilder;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceDirectives",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphqlDirectivesContainerTypeBuilder;",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withDirectives",
+            "desc": "([Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphqlDirectivesContainerTypeBuilder;",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "withDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphqlDirectivesContainerTypeBuilder;",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective$Builder;)Lgraphql/schema/GraphqlDirectivesContainerTypeBuilder;",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "clearDirectives",
+            "desc": "()Lgraphql/schema/GraphqlDirectivesContainerTypeBuilder;",
+            "line": 119,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "copyExistingDirectives",
+            "desc": "(Lgraphql/schema/GraphQLDirectiveContainer;)V",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.TypeResolverProxy": {
+        "line": {
+          "covered": 1,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 2
+        },
+        "method": {
+          "covered": 1,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 8,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeResolver",
+            "desc": "()Lgraphql/schema/TypeResolver;",
+            "line": 13,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "setTypeResolver",
+            "desc": "(Lgraphql/schema/TypeResolver;)V",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getType",
+            "desc": "(Lgraphql/TypeResolutionEnvironment;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.CodeRegistryVisitor": {
+        "line": {
+          "covered": 22,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 8,
+          "missed": 2
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLCodeRegistry$Builder;)V",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInterfaceType",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLUnionType",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLArgument$Builder": {
+        "line": {
+          "covered": 41,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 17,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 330,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLArgument;)V",
+            "line": 330,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "definition",
+            "desc": "(Lgraphql/language/InputValueDefinition;)Lgraphql/schema/GraphQLArgument$Builder;",
+            "line": 351,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deprecate",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLArgument$Builder;",
+            "line": 356,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "type",
+            "desc": "(Lgraphql/schema/GraphQLInputType;)Lgraphql/schema/GraphQLArgument$Builder;",
+            "line": 361,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "defaultValue",
+            "desc": "(Ljava/lang/Object;)Lgraphql/schema/GraphQLArgument$Builder;",
+            "line": 376,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "defaultValueLiteral",
+            "desc": "(Lgraphql/language/Value;)Lgraphql/schema/GraphQLArgument$Builder;",
+            "line": 386,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "defaultValueProgrammatic",
+            "desc": "(Ljava/lang/Object;)Lgraphql/schema/GraphQLArgument$Builder;",
+            "line": 396,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clearDefaultValue",
+            "desc": "()Lgraphql/schema/GraphQLArgument$Builder;",
+            "line": 406,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "value",
+            "desc": "(Ljava/lang/Object;)Lgraphql/schema/GraphQLArgument$Builder;",
+            "line": 421,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "valueLiteral",
+            "desc": "(Lgraphql/language/Value;)Lgraphql/schema/GraphQLArgument$Builder;",
+            "line": 436,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "valueProgrammatic",
+            "desc": "(Ljava/lang/Object;)Lgraphql/schema/GraphQLArgument$Builder;",
+            "line": 449,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clearValue",
+            "desc": "()Lgraphql/schema/GraphQLArgument$Builder;",
+            "line": 462,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "replaceDirectives",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLArgument$Builder;",
+            "line": 469,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withDirectives",
+            "desc": "([Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLArgument$Builder;",
+            "line": 474,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "withDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLArgument$Builder;",
+            "line": 479,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective$Builder;)Lgraphql/schema/GraphQLArgument$Builder;",
+            "line": 484,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "clearDirectives",
+            "desc": "()Lgraphql/schema/GraphQLArgument$Builder;",
+            "line": 489,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLArgument$Builder;",
+            "line": 494,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLArgument$Builder;",
+            "line": 499,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/GraphQLArgument;",
+            "line": 503,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLSchema$FastBuilder": {
+        "line": {
+          "covered": 90,
+          "missed": 9
+        },
+        "branch": {
+          "covered": 42,
+          "missed": 0
+        },
+        "method": {
+          "covered": 14,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLCodeRegistry$Builder;Lgraphql/schema/GraphQLObjectType;Lgraphql/schema/GraphQLObjectType;Lgraphql/schema/GraphQLObjectType;)V",
+            "line": 1173,
+            "counters": {
+              "line": {
+                "covered": 29,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addType",
+            "desc": "(Lgraphql/schema/GraphQLNamedType;)Lgraphql/schema/GraphQLSchema$FastBuilder;",
+            "line": 1247,
+            "counters": {
+              "line": {
+                "covered": 19,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 14,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addTypes",
+            "desc": "(Ljava/util/Collection;)Lgraphql/schema/GraphQLSchema$FastBuilder;",
+            "line": 1296,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLSchema$FastBuilder;",
+            "line": 1308,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalDirectives",
+            "desc": "(Ljava/util/Collection;)Lgraphql/schema/GraphQLSchema$FastBuilder;",
+            "line": 1330,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withSchemaDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLSchema$FastBuilder;",
+            "line": 1342,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "withSchemaDirectives",
+            "desc": "(Ljava/util/Collection;)Lgraphql/schema/GraphQLSchema$FastBuilder;",
+            "line": 1354,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "withSchemaAppliedDirective",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirective;)Lgraphql/schema/GraphQLSchema$FastBuilder;",
+            "line": 1366,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withSchemaAppliedDirectives",
+            "desc": "(Ljava/util/Collection;)Lgraphql/schema/GraphQLSchema$FastBuilder;",
+            "line": 1380,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "definition",
+            "desc": "(Lgraphql/language/SchemaDefinition;)Lgraphql/schema/GraphQLSchema$FastBuilder;",
+            "line": 1394,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "extensionDefinitions",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLSchema$FastBuilder;",
+            "line": 1406,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLSchema$FastBuilder;",
+            "line": 1418,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "introspectionSchemaType",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;)Lgraphql/schema/GraphQLSchema$FastBuilder;",
+            "line": 1430,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "withValidation",
+            "desc": "(Z)Lgraphql/schema/GraphQLSchema$FastBuilder;",
+            "line": 1442,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/GraphQLSchema;",
+            "line": 1462,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 14,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addDirectiveIfMissing",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)V",
+            "line": 1493,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$1",
+            "desc": "()Ljava/lang/String;",
+            "line": 1199,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$0",
+            "desc": "()Ljava/lang/String;",
+            "line": 1198,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphqlTypeComparatorRegistry": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 13,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.CoercingParseLiteralException": {
+        "line": {
+          "covered": 5,
+          "missed": 9
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 5
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 12,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/Throwable;)V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/Throwable;Lgraphql/language/SourceLocation;)V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Throwable;)V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/CoercingParseLiteralException$Builder;)V",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/ErrorType;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "newCoercingParseLiteralException",
+            "desc": "()Lgraphql/schema/CoercingParseLiteralException$Builder;",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLAppliedDirective$Builder": {
+        "line": {
+          "covered": 24,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 8,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirective;)V",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "argument",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirectiveArgument;)Lgraphql/schema/GraphQLAppliedDirective$Builder;",
+            "line": 175,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceArguments",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLAppliedDirective$Builder;",
+            "line": 181,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "argument",
+            "desc": "(Ljava/util/function/UnaryOperator;)Lgraphql/schema/GraphQLAppliedDirective$Builder;",
+            "line": 203,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "argument",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirectiveArgument$Builder;)Lgraphql/schema/GraphQLAppliedDirective$Builder;",
+            "line": 217,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clearArguments",
+            "desc": "()Lgraphql/schema/GraphQLAppliedDirective$Builder;",
+            "line": 226,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "definition",
+            "desc": "(Lgraphql/language/Directive;)Lgraphql/schema/GraphQLAppliedDirective$Builder;",
+            "line": 232,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/GraphQLAppliedDirective;",
+            "line": 237,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.SchemaTransformer": {
+        "line": {
+          "covered": 144,
+          "missed": 15
+        },
+        "branch": {
+          "covered": 60,
+          "missed": 11
+        },
+        "method": {
+          "covered": 13,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transformSchema",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLTypeVisitor;)Lgraphql/schema/GraphQLSchema;",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transformSchema",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLTypeVisitor;Ljava/util/function/Consumer;)Lgraphql/schema/GraphQLSchema;",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "transformSchemaWithDeletes",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLTypeVisitor;)Lgraphql/schema/GraphQLSchema;",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transformSchemaWithDeletes",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLTypeVisitor;Ljava/util/function/Consumer;)Lgraphql/schema/GraphQLSchema;",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transformSchema",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;Lgraphql/schema/GraphQLTypeVisitor;)Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 171,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLTypeVisitor;)Lgraphql/schema/GraphQLSchema;",
+            "line": 176,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLTypeVisitor;Ljava/util/function/Consumer;)Lgraphql/schema/GraphQLSchema;",
+            "line": 180,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;Lgraphql/schema/GraphQLTypeVisitor;)Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 185,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transformImpl",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLSchemaElement;Lgraphql/schema/GraphQLTypeVisitor;Ljava/util/function/Consumer;Z)Ljava/lang/Object;",
+            "line": 194,
+            "counters": {
+              "line": {
+                "covered": 20,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 12,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceTypeReferences",
+            "desc": "(Lgraphql/schema/SchemaTransformer$DummyRoot;Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLCodeRegistry$Builder;Ljava/util/Map;)V",
+            "line": 234,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "traverseAndTransform",
+            "desc": "(Lgraphql/schema/SchemaTransformer$DummyRoot;Ljava/util/Map;Ljava/util/Set;Ljava/util/Map;Lgraphql/schema/GraphQLTypeVisitor;Lgraphql/schema/GraphQLCodeRegistry$Builder;Lgraphql/schema/GraphQLSchema;)Z",
+            "line": 254,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "zipUpToDummyRoot",
+            "desc": "(Ljava/util/List;Ljava/util/List;Ljava/util/Map;Ljava/util/Map;Ljava/util/Set;)Z",
+            "line": 409,
+            "counters": {
+              "line": {
+                "covered": 37,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 22,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "zipperWithSameParent",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;Lgraphql/schema/SchemaTransformer$RelevantZippersAndBreadcrumbs;Z)Ljava/util/Map;",
+            "line": 473,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 9,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "moveUp",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;Ljava/util/Map;Ljava/util/Set;)Lgraphql/util/NodeZipper;",
+            "line": 503,
+            "counters": {
+              "line": {
+                "covered": 34,
+                "missed": 5
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$moveUp$0",
+            "desc": "(Lgraphql/schema/SchemaTransformer$ZipperWithOneParent;Lgraphql/schema/SchemaTransformer$ZipperWithOneParent;)I",
+            "line": 516,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 5
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.DataFetchingEnvironment": {
+        "line": {
+          "covered": 0,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 0,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "toInternal",
+            "desc": "()Ljava/lang/Object;",
+            "line": 287,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLScalarType$Builder": {
+        "line": {
+          "covered": 28,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 12,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 224,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLScalarType;)V",
+            "line": 224,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "specifiedByUrl",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLScalarType$Builder;",
+            "line": 241,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "definition",
+            "desc": "(Lgraphql/language/ScalarTypeDefinition;)Lgraphql/schema/GraphQLScalarType$Builder;",
+            "line": 246,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "extensionDefinitions",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLScalarType$Builder;",
+            "line": 251,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "coercing",
+            "desc": "(Lgraphql/schema/Coercing;)Lgraphql/schema/GraphQLScalarType$Builder;",
+            "line": 256,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceDirectives",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLScalarType$Builder;",
+            "line": 264,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withDirectives",
+            "desc": "([Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLScalarType$Builder;",
+            "line": 269,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "withDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLScalarType$Builder;",
+            "line": 274,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective$Builder;)Lgraphql/schema/GraphQLScalarType$Builder;",
+            "line": 279,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "clearDirectives",
+            "desc": "()Lgraphql/schema/GraphQLScalarType$Builder;",
+            "line": 284,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLScalarType$Builder;",
+            "line": 289,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLScalarType$Builder;",
+            "line": 294,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/GraphQLScalarType;",
+            "line": 298,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLSchema": {
+        "line": {
+          "covered": 196,
+          "missed": 9
+        },
+        "branch": {
+          "covered": 30,
+          "missed": 4
+        },
+        "method": {
+          "covered": 49,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLSchema$Builder;)V",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 23,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLCodeRegistry;Lcom/google/common/collect/ImmutableMap;Lcom/google/common/collect/ImmutableMap;)V",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 20,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLSchema$BuilderWithoutTypes;)V",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 21,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLSchema$FastBuilder;)V",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 39,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "schemaDirectivesArray",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)[Lgraphql/schema/GraphQLDirective;",
+            "line": 228,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "schemaAppliedDirectivesArray",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)[Lgraphql/schema/GraphQLAppliedDirective;",
+            "line": 232,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllTypesAsList",
+            "desc": "(Lcom/google/common/collect/ImmutableMap;)Ljava/util/List;",
+            "line": 236,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildInterfacesToObjectTypes",
+            "desc": "(Ljava/util/Map;)Lcom/google/common/collect/ImmutableMap;",
+            "line": 240,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildInterfacesToObjectName",
+            "desc": "(Lcom/google/common/collect/ImmutableMap;)Lcom/google/common/collect/ImmutableMap;",
+            "line": 249,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCodeRegistry",
+            "desc": "()Lgraphql/schema/GraphQLCodeRegistry;",
+            "line": 258,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getIntrospectionSchemaFieldDefinition",
+            "desc": "()Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 265,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getIntrospectionTypeFieldDefinition",
+            "desc": "()Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 272,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getIntrospectionTypenameFieldDefinition",
+            "desc": "()Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 279,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getIntrospectionSchemaType",
+            "desc": "()Lgraphql/schema/GraphQLObjectType;",
+            "line": 283,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAdditionalTypes",
+            "desc": "()Ljava/util/Set;",
+            "line": 353,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getType",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLType;",
+            "line": 364,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypes",
+            "desc": "(Ljava/util/Collection;)Ljava/util/List;",
+            "line": 378,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 5
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getTypeAs",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLType;",
+            "line": 397,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "containsType",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 408,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getObjectType",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 421,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinition",
+            "desc": "(Lgraphql/schema/FieldCoordinates;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 438,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 9,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeMap",
+            "desc": "()Ljava/util/Map;",
+            "line": 465,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllTypesAsList",
+            "desc": "()Ljava/util/List;",
+            "line": 474,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllElementsAsList",
+            "desc": "()Ljava/util/List;",
+            "line": 484,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getImplementations",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;)Ljava/util/List;",
+            "line": 499,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isPossibleType",
+            "desc": "(Lgraphql/schema/GraphQLNamedType;Lgraphql/schema/GraphQLObjectType;)Z",
+            "line": 514,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getQueryType",
+            "desc": "()Lgraphql/schema/GraphQLObjectType;",
+            "line": 527,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMutationType",
+            "desc": "()Lgraphql/schema/GraphQLObjectType;",
+            "line": 534,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSubscriptionType",
+            "desc": "()Lgraphql/schema/GraphQLObjectType;",
+            "line": 541,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 551,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 558,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLDirective;",
+            "line": 569,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSchemaDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 585,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSchemaDirectiveByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 600,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllSchemaDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 615,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getSchemaDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLDirective;",
+            "line": 632,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSchemaDirectives",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 647,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getSchemaAppliedDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 659,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllSchemaAppliedDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 671,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSchemaAppliedDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLAppliedDirective;",
+            "line": 685,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSchemaAppliedDirectives",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 689,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefinition",
+            "desc": "()Lgraphql/language/SchemaDefinition;",
+            "line": 694,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExtensionDefinitions",
+            "desc": "()Ljava/util/List;",
+            "line": 698,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isSupportingMutations",
+            "desc": "()Z",
+            "line": 702,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isSupportingSubscriptions",
+            "desc": "()Z",
+            "line": 706,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDescription",
+            "desc": "()Ljava/lang/String;",
+            "line": 711,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/schema/GraphQLSchema;",
+            "line": 723,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transformWithoutTypes",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/schema/GraphQLSchema;",
+            "line": 737,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newSchema",
+            "desc": "()Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 746,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newSchema",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 758,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$1",
+            "desc": "(Ljava/util/Set;Lgraphql/schema/GraphQLNamedType;)Z",
+            "line": 210,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$0",
+            "desc": "(Lcom/google/common/collect/ImmutableMap;Ljava/lang/String;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 187,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLObjectType": {
+        "line": {
+          "covered": 55,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 25,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/util/List;Ljava/util/List;Ljava/util/List;Lgraphql/language/ObjectTypeDefinition;Ljava/util/List;Ljava/util/Comparator;)V",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceInterfaces",
+            "desc": "(Ljava/util/List;)V",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildDefinitionMap",
+            "desc": "(Ljava/util/List;)Ljava/util/Map;",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLDirective;",
+            "line": 106,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllAppliedDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLAppliedDirective;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinition",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinitions",
+            "desc": "()Ljava/util/List;",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInterfaces",
+            "desc": "()Ljava/util/List;",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDescription",
+            "desc": "()Ljava/lang/String;",
+            "line": 143,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 149,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefinition",
+            "desc": "()Lgraphql/language/ObjectTypeDefinition;",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExtensionDefinitions",
+            "desc": "()Ljava/util/List;",
+            "line": 157,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 179,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "copy",
+            "desc": "()Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 186,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 191,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 196,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildrenWithTypeReferences",
+            "desc": "()Lgraphql/schema/SchemaElementChildrenContainer;",
+            "line": 205,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;)Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 216,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newObject",
+            "desc": "()Lgraphql/schema/GraphQLObjectType$Builder;",
+            "line": 243,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newObject",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;)Lgraphql/schema/GraphQLObjectType$Builder;",
+            "line": 247,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;Lgraphql/schema/GraphQLObjectType$Builder;)V",
+            "line": 217,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildDefinitionMap$0",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/GraphQLFieldDefinition;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLEnumType": {
+        "line": {
+          "covered": 76,
+          "missed": 10
+        },
+        "branch": {
+          "covered": 20,
+          "missed": 4
+        },
+        "method": {
+          "covered": 30,
+          "missed": 7
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/util/List;Ljava/util/List;Lgraphql/language/EnumTypeDefinition;Ljava/util/List;)V",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "serialize",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "serialize",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseValue",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "parseValue",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseLiteral",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "parseLiteral",
+            "desc": "(Lgraphql/language/Value;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseLiteralImpl",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "valueToLiteral",
+            "desc": "(Ljava/lang/Object;)Lgraphql/language/Value;",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "valueToLiteral",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Lgraphql/language/Value;",
+            "line": 135,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getValues",
+            "desc": "()Ljava/util/List;",
+            "line": 144,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getValue",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLEnumValueDefinition;",
+            "line": 148,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildMap",
+            "desc": "(Ljava/util/List;)Lcom/google/common/collect/ImmutableMap;",
+            "line": 152,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getValueByName",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 157,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNameByValue",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 165,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 14,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 192,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDescription",
+            "desc": "()Ljava/lang/String;",
+            "line": 196,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefinition",
+            "desc": "()Lgraphql/language/EnumTypeDefinition;",
+            "line": 200,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExtensionDefinitions",
+            "desc": "()Ljava/util/List;",
+            "line": 204,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 209,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 214,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 219,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLDirective;",
+            "line": 224,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 229,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllAppliedDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 234,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLAppliedDirective;",
+            "line": 239,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/schema/GraphQLEnumType;",
+            "line": 251,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "copy",
+            "desc": "()Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 258,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 264,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 269,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildrenWithTypeReferences",
+            "desc": "()Lgraphql/schema/SchemaElementChildrenContainer;",
+            "line": 277,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;)Lgraphql/schema/GraphQLEnumType;",
+            "line": 286,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 312,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "newEnum",
+            "desc": "()Lgraphql/schema/GraphQLEnumType$Builder;",
+            "line": 323,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newEnum",
+            "desc": "(Lgraphql/schema/GraphQLEnumType;)Lgraphql/schema/GraphQLEnumType$Builder;",
+            "line": 327,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;Lgraphql/schema/GraphQLEnumType$Builder;)V",
+            "line": 287,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildMap$0",
+            "desc": "(Lgraphql/schema/GraphQLEnumValueDefinition;Lgraphql/schema/GraphQLEnumValueDefinition;)Lgraphql/schema/GraphQLEnumValueDefinition;",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLFieldDefinition": {
+        "line": {
+          "covered": 63,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 10,
+          "missed": 0
+        },
+        "method": {
+          "covered": 27,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Lgraphql/schema/GraphQLOutputType;Lgraphql/schema/DataFetcherFactory;Ljava/util/List;Ljava/lang/String;Ljava/util/List;Ljava/util/List;Lgraphql/language/FieldDefinition;)V",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceType",
+            "desc": "(Lgraphql/schema/GraphQLOutputType;)V",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getType",
+            "desc": "()Lgraphql/schema/GraphQLOutputType;",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDataFetcher",
+            "desc": "()Lgraphql/schema/DataFetcher;",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgument",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLArgument;",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 113,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 118,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 123,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLDirective;",
+            "line": 128,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 133,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllAppliedDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLAppliedDirective;",
+            "line": 143,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArguments",
+            "desc": "()Ljava/util/List;",
+            "line": 147,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDescription",
+            "desc": "()Ljava/lang/String;",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefinition",
+            "desc": "()Lgraphql/language/FieldDefinition;",
+            "line": 155,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDeprecationReason",
+            "desc": "()Ljava/lang/String;",
+            "line": 159,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isDeprecated",
+            "desc": "()Z",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 168,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 188,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "copy",
+            "desc": "()Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 195,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 201,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 206,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildrenWithTypeReferences",
+            "desc": "()Lgraphql/schema/SchemaElementChildrenContainer;",
+            "line": 216,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;)Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 227,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 252,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newFieldDefinition",
+            "desc": "()Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 256,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;Lgraphql/schema/GraphQLFieldDefinition$Builder;)V",
+            "line": 228,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.Coercing": {
+        "line": {
+          "covered": 16,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "serialize",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "serialize",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseValue",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "parseValue",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 123,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseLiteral",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 148,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "parseLiteral",
+            "desc": "(Ljava/lang/Object;Ljava/util/Map;)Ljava/lang/Object;",
+            "line": 176,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseLiteral",
+            "desc": "(Lgraphql/language/Value;Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 202,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "valueToLiteral",
+            "desc": "(Ljava/lang/Object;)Lgraphql/language/Value;",
+            "line": 222,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "valueToLiteral",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Lgraphql/language/Value;",
+            "line": 237,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLSchema$Builder": {
+        "line": {
+          "covered": 93,
+          "missed": 7
+        },
+        "branch": {
+          "covered": 16,
+          "missed": 2
+        },
+        "method": {
+          "covered": 27,
+          "missed": 6
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 806,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "query",
+            "desc": "(Lgraphql/schema/GraphQLObjectType$Builder;)Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 822,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "query",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;)Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 826,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mutation",
+            "desc": "(Lgraphql/schema/GraphQLObjectType$Builder;)Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 831,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "mutation",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;)Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 835,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "subscription",
+            "desc": "(Lgraphql/schema/GraphQLObjectType$Builder;)Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 840,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "subscription",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;)Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 844,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "codeRegistry",
+            "desc": "(Lgraphql/schema/GraphQLCodeRegistry;)Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 849,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalTypes",
+            "desc": "(Ljava/util/Set;)Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 881,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalType",
+            "desc": "(Lgraphql/schema/GraphQLNamedType;)Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 904,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clearAdditionalTypes",
+            "desc": "()Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 920,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalDirectives",
+            "desc": "(Ljava/util/Set;)Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 925,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "additionalDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 930,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clearDirectives",
+            "desc": "()Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 954,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withSchemaDirectives",
+            "desc": "([Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 959,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withSchemaDirectives",
+            "desc": "(Ljava/util/Collection;)Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 966,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withSchemaDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 973,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withSchemaDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective$Builder;)Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 979,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "withSchemaAppliedDirectives",
+            "desc": "([Lgraphql/schema/GraphQLAppliedDirective;)Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 983,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withSchemaAppliedDirectives",
+            "desc": "(Ljava/util/Collection;)Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 990,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withSchemaAppliedDirective",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirective;)Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 997,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withSchemaAppliedDirective",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirective$Builder;)Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 1003,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "clearSchemaDirectives",
+            "desc": "()Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 1012,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "definition",
+            "desc": "(Lgraphql/language/SchemaDefinition;)Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 1018,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "extensionDefinitions",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 1023,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 1028,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "introspectionSchemaType",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;)Lgraphql/schema/GraphQLSchema$Builder;",
+            "line": 1033,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/GraphQLSchema;",
+            "line": 1043,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildImpl",
+            "desc": "()Lgraphql/schema/GraphQLSchema;",
+            "line": 1047,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ensureBuiltInDirectives",
+            "desc": "()V",
+            "line": 1076,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateSchema",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Lgraphql/schema/GraphQLSchema;",
+            "line": 1092,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addBuiltInDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;Ljava/util/Set;)V",
+            "line": 1100,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$addBuiltInDirective$0",
+            "desc": "(Lgraphql/schema/GraphQLDirective;Lgraphql/schema/GraphQLDirective;)Z",
+            "line": 1100,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.SchemaTransformer$ZipperWithOneParent": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/util/NodeZipper;Lgraphql/util/Breadcrumb;)V",
+            "line": 589,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.PropertyFetchingImpl$CachedMethod": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/PropertyFetchingImpl;Ljava/lang/reflect/Method;)V",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphqlTypeComparatorEnvironment$Builder": {
+        "line": {
+          "covered": 11,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphqlTypeComparatorEnvironment;)V",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parentType",
+            "desc": "(Ljava/lang/Class;)Lgraphql/schema/GraphqlTypeComparatorEnvironment$Builder;",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "elementType",
+            "desc": "(Ljava/lang/Class;)Lgraphql/schema/GraphqlTypeComparatorEnvironment$Builder;",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/GraphqlTypeComparatorEnvironment;",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLCodeRegistry": {
+        "line": {
+          "covered": 63,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 21,
+          "missed": 1
+        },
+        "method": {
+          "covered": 18,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLCodeRegistry$Builder;)V",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildDataFetcherByNames",
+            "desc": "(Ljava/util/Map;)Ljava/util/Map;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldVisibility",
+            "desc": "()Lgraphql/schema/visibility/GraphqlFieldVisibility;",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDataFetcher",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/schema/GraphQLFieldDefinition;)Lgraphql/schema/DataFetcher;",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDataFetcher",
+            "desc": "(Lgraphql/schema/FieldCoordinates;Lgraphql/schema/GraphQLFieldDefinition;)Lgraphql/schema/DataFetcher;",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasDataFetcher",
+            "desc": "(Lgraphql/schema/FieldCoordinates;)Z",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDataFetcher",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Lgraphql/schema/GraphQLFieldDefinition;)Lgraphql/schema/DataFetcher;",
+            "line": 118,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDataFetcherImpl",
+            "desc": "(Lgraphql/schema/FieldCoordinates;Lgraphql/schema/GraphQLFieldDefinition;Ljava/util/Map;Ljava/util/Map;Lgraphql/schema/DataFetcherFactory;)Lgraphql/schema/DataFetcher;",
+            "line": 133,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "resolveDataFetcher",
+            "desc": "(Lgraphql/schema/DataFetcherFactory;Lgraphql/schema/GraphQLFieldDefinition;)Lgraphql/schema/DataFetcher;",
+            "line": 149,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasDataFetcherImpl",
+            "desc": "(Lgraphql/schema/FieldCoordinates;Ljava/util/Map;Ljava/util/Map;)Z",
+            "line": 160,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeResolver",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;)Lgraphql/schema/TypeResolver;",
+            "line": 178,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeResolver",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;)Lgraphql/schema/TypeResolver;",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeResolverForInterface",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;Ljava/util/Map;)Lgraphql/schema/TypeResolver;",
+            "line": 194,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeResolverForUnion",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;Ljava/util/Map;)Lgraphql/schema/TypeResolver;",
+            "line": 203,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/schema/GraphQLCodeRegistry;",
+            "line": 220,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newCodeRegistry",
+            "desc": "()Lgraphql/schema/GraphQLCodeRegistry$Builder;",
+            "line": 229,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newCodeRegistry",
+            "desc": "(Lgraphql/schema/GraphQLCodeRegistry;)Lgraphql/schema/GraphQLCodeRegistry$Builder;",
+            "line": 240,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildDataFetcherByNames$0",
+            "desc": "(Ljava/lang/String;)Ljava/util/Map;",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLUnionType$Builder": {
+        "line": {
+          "covered": 48,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 7,
+          "missed": 5
+        },
+        "method": {
+          "covered": 17,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 261,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;)V",
+            "line": 261,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "definition",
+            "desc": "(Lgraphql/language/UnionTypeDefinition;)Lgraphql/schema/GraphQLUnionType$Builder;",
+            "line": 278,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "extensionDefinitions",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLUnionType$Builder;",
+            "line": 283,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "typeResolver",
+            "desc": "(Lgraphql/schema/TypeResolver;)Lgraphql/schema/GraphQLUnionType$Builder;",
+            "line": 296,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "possibleType",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;)Lgraphql/schema/GraphQLUnionType$Builder;",
+            "line": 301,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "possibleType",
+            "desc": "(Lgraphql/schema/GraphQLTypeReference;)Lgraphql/schema/GraphQLUnionType$Builder;",
+            "line": 307,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "possibleTypes",
+            "desc": "([Lgraphql/schema/GraphQLObjectType;)Lgraphql/schema/GraphQLUnionType$Builder;",
+            "line": 313,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replacePossibleTypes",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLUnionType$Builder;",
+            "line": 320,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "possibleTypes",
+            "desc": "([Lgraphql/schema/GraphQLTypeReference;)Lgraphql/schema/GraphQLUnionType$Builder;",
+            "line": 334,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "clearPossibleTypes",
+            "desc": "()Lgraphql/schema/GraphQLUnionType$Builder;",
+            "line": 346,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "containType",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 351,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceDirectives",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLUnionType$Builder;",
+            "line": 358,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withDirectives",
+            "desc": "([Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLUnionType$Builder;",
+            "line": 363,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "withDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLUnionType$Builder;",
+            "line": 368,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective$Builder;)Lgraphql/schema/GraphQLUnionType$Builder;",
+            "line": 373,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "clearDirectives",
+            "desc": "()Lgraphql/schema/GraphQLUnionType$Builder;",
+            "line": 378,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLUnionType$Builder;",
+            "line": 383,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLUnionType$Builder;",
+            "line": 388,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/GraphQLUnionType;",
+            "line": 392,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.StaticDataFetcher": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "get",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.DelegatingDataFetchingEnvironment": {
+        "line": {
+          "covered": 8,
+          "missed": 23
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 23
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)V",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSource",
+            "desc": "()Ljava/lang/Object;",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArguments",
+            "desc": "()Ljava/util/Map;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "containsArgument",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getArgument",
+            "desc": "(Ljava/lang/String;)Ljava/lang/Object;",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getArgumentOrDefault",
+            "desc": "(Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getContext",
+            "desc": "()Ljava/lang/Object;",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getGraphQlContext",
+            "desc": "()Lgraphql/GraphQLContext;",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getLocalContext",
+            "desc": "()Ljava/lang/Object;",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getRoot",
+            "desc": "()Ljava/lang/Object;",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinition",
+            "desc": "()Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getFields",
+            "desc": "()Ljava/util/List;",
+            "line": 97,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getMergedField",
+            "desc": "()Lgraphql/execution/MergedField;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getField",
+            "desc": "()Lgraphql/language/Field;",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getFieldType",
+            "desc": "()Lgraphql/schema/GraphQLOutputType;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getExecutionStepInfo",
+            "desc": "()Lgraphql/execution/ExecutionStepInfo;",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getParentType",
+            "desc": "()Lgraphql/schema/GraphQLType;",
+            "line": 122,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getGraphQLSchema",
+            "desc": "()Lgraphql/schema/GraphQLSchema;",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getFragmentsByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getExecutionId",
+            "desc": "()Lgraphql/execution/ExecutionId;",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getSelectionSet",
+            "desc": "()Lgraphql/schema/DataFetchingFieldSelectionSet;",
+            "line": 142,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getQueryDirectives",
+            "desc": "()Lgraphql/execution/directives/QueryDirectives;",
+            "line": 147,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDataLoader",
+            "desc": "(Ljava/lang/String;)Lorg/dataloader/DataLoader;",
+            "line": 152,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDataLoaderRegistry",
+            "desc": "()Lorg/dataloader/DataLoaderRegistry;",
+            "line": 157,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getLocale",
+            "desc": "()Ljava/util/Locale;",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getOperationDefinition",
+            "desc": "()Lgraphql/language/OperationDefinition;",
+            "line": 167,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDocument",
+            "desc": "()Lgraphql/language/Document;",
+            "line": 172,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getVariables",
+            "desc": "()Ljava/util/Map;",
+            "line": 177,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toInternal",
+            "desc": "()Ljava/lang/Object;",
+            "line": 182,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.DataFetchingFieldSelectionSetImpl": {
+        "line": {
+          "covered": 102,
+          "missed": 9
+        },
+        "branch": {
+          "covered": 49,
+          "missed": 9
+        },
+        "method": {
+          "covered": 22,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "newCollector",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLOutputType;Ljava/util/function/Supplier;)Lgraphql/schema/DataFetchingFieldSelectionSet;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/function/Supplier;Lgraphql/schema/GraphQLSchema;)V",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "contains",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "osAppropriate",
+            "desc": "(Ljava/lang/String;)Ljava/lang/String;",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "containsAnyOf",
+            "desc": "(Ljava/lang/String;[Ljava/lang/String;)Z",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "containsAllOf",
+            "desc": "(Ljava/lang/String;[Ljava/lang/String;)Z",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFields",
+            "desc": "(Ljava/lang/String;[Ljava/lang/String;)Ljava/util/List;",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFields",
+            "desc": "()Ljava/util/List;",
+            "line": 184,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toSetSemanticsList",
+            "desc": "(Ljava/util/stream/Stream;)Ljava/util/List;",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getImmediateFields",
+            "desc": "()Ljava/util/List;",
+            "line": 196,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldsGroupedByResultKey",
+            "desc": "()Ljava/util/Map;",
+            "line": 202,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldsGroupedByResultKey",
+            "desc": "(Ljava/lang/String;[Ljava/lang/String;)Ljava/util/Map;",
+            "line": 207,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "computeValuesLazily",
+            "desc": "(Z)V",
+            "line": 211,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "traverseSubSelectedFields",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;Lcom/google/common/collect/ImmutableList$Builder;Ljava/lang/String;Ljava/lang/String;ZZ)V",
+            "line": 244,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "removeLeadingSlash",
+            "desc": "(Ljava/lang/String;)Ljava/lang/String;",
+            "line": 271,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkTypeQualifiedName",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;)Ljava/lang/String;",
+            "line": 278,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkFieldGlobName",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
+            "line": 282,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "globMatcher",
+            "desc": "(Ljava/lang/String;)Ljava/nio/file/PathMatcher;",
+            "line": 286,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkIterable",
+            "desc": "(Ljava/lang/String;[Ljava/lang/String;)Ljava/util/List;",
+            "line": 290,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 298,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$computeValuesLazily$0",
+            "desc": "(ZLgraphql/normalized/ExecutableNormalizedField;)V",
+            "line": 225,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getFields$0",
+            "desc": "(Ljava/lang/String;)Ljava/util/stream/Stream;",
+            "line": 179,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphqlTypeBuilder": {
+        "line": {
+          "covered": 17,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 8,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 14,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphqlTypeBuilder;",
+            "line": 21,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphqlTypeBuilder;",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "comparatorRegistry",
+            "desc": "(Lgraphql/schema/GraphqlTypeComparatorRegistry;)Lgraphql/schema/GraphqlTypeBuilder;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sort",
+            "desc": "(Ljava/util/Map;Ljava/lang/Class;Ljava/lang/Class;)Ljava/util/List;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sort",
+            "desc": "(Ljava/util/List;Ljava/lang/Class;Ljava/lang/Class;)Ljava/util/List;",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getComparator",
+            "desc": "(Ljava/lang/Class;Ljava/lang/Class;)Ljava/util/Comparator;",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getComparatorImpl",
+            "desc": "(Lgraphql/schema/GraphqlTypeComparatorRegistry;Ljava/lang/Class;Ljava/lang/Class;)Ljava/util/Comparator;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.ShallowTypeRefCollector$UnionTypesReplaceTarget": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;)V",
+            "line": 159,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.AsyncDataFetcher": {
+        "line": {
+          "covered": 10,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 2
+        },
+        "method": {
+          "covered": 6,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "async",
+            "desc": "(Lgraphql/schema/DataFetcher;)Lgraphql/schema/AsyncDataFetcher;",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "async",
+            "desc": "(Lgraphql/schema/DataFetcher;Ljava/util/concurrent/Executor;)Lgraphql/schema/AsyncDataFetcher;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getWrappedDataFetcher",
+            "desc": "()Lgraphql/schema/DataFetcher;",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getExecutor",
+            "desc": "()Ljava/util/concurrent/Executor;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/DataFetcher;)V",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/DataFetcher;Ljava/util/concurrent/Executor;)V",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "get",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$get$0",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.ShallowTypeRefCollector": {
+        "line": {
+          "covered": 212,
+          "missed": 10
+        },
+        "branch": {
+          "covered": 120,
+          "missed": 18
+        },
+        "method": {
+          "covered": 24,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleTypeDef",
+            "desc": "(Lgraphql/schema/GraphQLNamedType;)V",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 11,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleEnumType",
+            "desc": "(Lgraphql/schema/GraphQLEnumType;)V",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleObjectType",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;)V",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 18,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasInterfaceTypeReferences",
+            "desc": "(Ljava/util/List;)Z",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleInterfaceType",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;)V",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleUnionType",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;)V",
+            "line": 145,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleInputObjectType",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;)V",
+            "line": 165,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "scanAppliedDirectives",
+            "desc": "(Ljava/util/List;)V",
+            "line": 180,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)V",
+            "line": 195,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "scanArgumentType",
+            "desc": "(Lgraphql/schema/GraphQLArgument;)V",
+            "line": 205,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "containsTypeReference",
+            "desc": "(Lgraphql/schema/GraphQLType;)Z",
+            "line": 214,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceTypes",
+            "desc": "(Ljava/util/Map;)V",
+            "line": 241,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 15,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceAppliedDirectiveArgumentType",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirectiveArgument;Ljava/util/Map;)V",
+            "line": 261,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceInputFieldType",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;Ljava/util/Map;)V",
+            "line": 266,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceArgumentType",
+            "desc": "(Lgraphql/schema/GraphQLArgument;Ljava/util/Map;)V",
+            "line": 271,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceFieldType",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Ljava/util/Map;)V",
+            "line": 276,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceObjectInterfaces",
+            "desc": "(Lgraphql/schema/ShallowTypeRefCollector$ObjectInterfaceReplaceTarget;Ljava/util/Map;)V",
+            "line": 281,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceInterfaceInterfaces",
+            "desc": "(Lgraphql/schema/ShallowTypeRefCollector$InterfaceInterfaceReplaceTarget;Ljava/util/Map;)V",
+            "line": 302,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceUnionTypes",
+            "desc": "(Lgraphql/schema/ShallowTypeRefCollector$UnionTypesReplaceTarget;Ljava/util/Map;)V",
+            "line": 323,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "resolveOutputType",
+            "desc": "(Lgraphql/schema/GraphQLOutputType;Ljava/util/Map;)Lgraphql/schema/GraphQLOutputType;",
+            "line": 348,
+            "counters": {
+              "line": {
+                "covered": 23,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 14,
+                "missed": 4
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "resolveInputType",
+            "desc": "(Lgraphql/schema/GraphQLInputType;Ljava/util/Map;)Lgraphql/schema/GraphQLInputType;",
+            "line": 390,
+            "counters": {
+              "line": {
+                "covered": 23,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 12,
+                "missed": 6
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInterfaceNameToObjectTypeNames",
+            "desc": "()Lcom/google/common/collect/ImmutableMap;",
+            "line": 434,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$handleObjectType$0",
+            "desc": "(Ljava/lang/String;)Ljava/util/TreeSet;",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.DataFetcherFactories": {
+        "line": {
+          "covered": 6,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 12,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "useDataFetcher",
+            "desc": "(Lgraphql/schema/DataFetcher;)Lgraphql/schema/DataFetcherFactory;",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "wrapDataFetcher",
+            "desc": "(Lgraphql/schema/DataFetcher;Ljava/util/function/BiFunction;)Lgraphql/schema/DataFetcher;",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$wrapDataFetcher$0",
+            "desc": "(Lgraphql/schema/DataFetcher;Ljava/util/function/BiFunction;Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$wrapDataFetcher$1",
+            "desc": "(Ljava/util/function/BiFunction;Lgraphql/schema/DataFetchingEnvironment;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLTypeResolvingVisitor$TypeRefResolvingVisitor": {
+        "line": {
+          "covered": 15,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLType;)V",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLArgument",
+            "desc": "(Lgraphql/schema/GraphQLArgument;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLAppliedDirectiveArgument",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirectiveArgument;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputObjectField",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLList",
+            "desc": "(Lgraphql/schema/GraphQLList;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLNonNull",
+            "desc": "(Lgraphql/schema/GraphQLNonNull;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLTypeVisitor": {
+        "line": {
+          "covered": 3,
+          "missed": 13
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 13
+        },
+        "methods": [
+          {
+            "name": "visitGraphQLAppliedDirective",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirective;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLAppliedDirectiveArgument",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirectiveArgument;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "visitBackRef",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLCompositeType",
+            "desc": "(Lgraphql/schema/GraphQLCompositeType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLDirectiveContainer",
+            "desc": "(Lgraphql/schema/GraphQLDirectiveContainer;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLFieldsContainer",
+            "desc": "(Lgraphql/schema/GraphQLFieldsContainer;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputFieldsContainer",
+            "desc": "(Lgraphql/schema/GraphQLInputFieldsContainer;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputType",
+            "desc": "(Lgraphql/schema/GraphQLInputType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLModifiedType",
+            "desc": "(Lgraphql/schema/GraphQLModifiedType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLNullableType",
+            "desc": "(Lgraphql/schema/GraphQLNullableType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLOutputType",
+            "desc": "(Lgraphql/schema/GraphQLOutputType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLUnmodifiedType",
+            "desc": "(Lgraphql/schema/GraphQLUnmodifiedType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 124,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "changeNode",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLSchemaElement;)Lgraphql/util/TraversalControl;",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deleteNode",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 147,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "insertAfter",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLSchemaElement;)Lgraphql/util/TraversalControl;",
+            "line": 159,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "insertBefore",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLSchemaElement;)Lgraphql/util/TraversalControl;",
+            "line": 171,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLArgument": {
+        "line": {
+          "covered": 58,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 30,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Lgraphql/schema/GraphQLInputType;Lgraphql/schema/InputValueWithState;Lgraphql/schema/InputValueWithState;Lgraphql/language/InputValueDefinition;Ljava/util/List;Ljava/util/List;Ljava/lang/String;)V",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceType",
+            "desc": "(Lgraphql/schema/GraphQLInputType;)V",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getType",
+            "desc": "()Lgraphql/schema/GraphQLInputType;",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentDefaultValue",
+            "desc": "()Lgraphql/schema/InputValueWithState;",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasSetDefaultValue",
+            "desc": "()Z",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasSetValue",
+            "desc": "()Z",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentValue",
+            "desc": "()Lgraphql/schema/InputValueWithState;",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentValue",
+            "desc": "(Lgraphql/schema/GraphQLArgument;)Ljava/lang/Object;",
+            "line": 152,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentDefaultValue",
+            "desc": "(Lgraphql/schema/GraphQLArgument;)Ljava/lang/Object;",
+            "line": 172,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDescription",
+            "desc": "()Ljava/lang/String;",
+            "line": 176,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDeprecationReason",
+            "desc": "()Ljava/lang/String;",
+            "line": 180,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isDeprecated",
+            "desc": "()Z",
+            "line": 184,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefinition",
+            "desc": "()Lgraphql/language/InputValueDefinition;",
+            "line": 188,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 193,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 198,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 203,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLDirective;",
+            "line": 208,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 213,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllAppliedDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 218,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLAppliedDirective;",
+            "line": 223,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 228,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildrenWithTypeReferences",
+            "desc": "()Lgraphql/schema/SchemaElementChildrenContainer;",
+            "line": 238,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;)Lgraphql/schema/GraphQLArgument;",
+            "line": 247,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "copy",
+            "desc": "()Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 256,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/schema/GraphQLArgument;",
+            "line": 286,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newArgument",
+            "desc": "()Lgraphql/schema/GraphQLArgument$Builder;",
+            "line": 292,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newArgument",
+            "desc": "(Lgraphql/schema/GraphQLArgument;)Lgraphql/schema/GraphQLArgument$Builder;",
+            "line": 296,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 301,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 306,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toAppliedArgument",
+            "desc": "()Lgraphql/schema/GraphQLAppliedDirectiveArgument;",
+            "line": 320,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;Lgraphql/schema/GraphQLArgument$Builder;)V",
+            "line": 248,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.DataLoaderWithContext": {
+        "line": {
+          "covered": 23,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 1
+        },
+        "method": {
+          "covered": 5,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;Ljava/lang/String;Lorg/dataloader/DataLoader;)V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "load",
+            "desc": "(Ljava/lang/Object;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "load",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "loadMany",
+            "desc": "(Ljava/util/List;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "loadMany",
+            "desc": "(Ljava/util/List;Ljava/util/List;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "loadMany",
+            "desc": "(Ljava/util/Map;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "newDataLoaderInvocation",
+            "desc": "()V",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLFieldsContainer": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "getField",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFields",
+            "desc": "()Ljava/util/List;",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLFieldDefinition$Builder": {
+        "line": {
+          "covered": 55,
+          "missed": 8
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 21,
+          "missed": 6
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 267,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;)V",
+            "line": 267,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "definition",
+            "desc": "(Lgraphql/language/FieldDefinition;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 284,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "type",
+            "desc": "(Lgraphql/schema/GraphQLObjectType$Builder;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 289,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "type",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType$Builder;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 293,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "type",
+            "desc": "(Lgraphql/schema/GraphQLUnionType$Builder;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 297,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "type",
+            "desc": "(Lgraphql/schema/GraphQLOutputType;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 301,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "dataFetcher",
+            "desc": "(Lgraphql/schema/DataFetcher;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 316,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "dataFetcherFactory",
+            "desc": "(Lgraphql/schema/DataFetcherFactory;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 332,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "staticValue",
+            "desc": "(Ljava/lang/Object;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 348,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "argument",
+            "desc": "(Lgraphql/schema/GraphQLArgument;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 353,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "argument",
+            "desc": "(Ljava/util/function/UnaryOperator;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 372,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "argument",
+            "desc": "(Lgraphql/schema/GraphQLArgument$Builder;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 386,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "argument",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 401,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "arguments",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 412,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceArguments",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 420,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clearArguments",
+            "desc": "()Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 434,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deprecate",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 440,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceDirectives",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 448,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withDirectives",
+            "desc": "([Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 453,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "withDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 458,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective$Builder;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 463,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "clearDirectives",
+            "desc": "()Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 468,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 473,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 478,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 482,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$staticValue$0",
+            "desc": "(Ljava/lang/Object;Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 348,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLEnumType$Builder": {
+        "line": {
+          "covered": 43,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 18,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 334,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLEnumType;)V",
+            "line": 334,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "definition",
+            "desc": "(Lgraphql/language/EnumTypeDefinition;)Lgraphql/schema/GraphQLEnumType$Builder;",
+            "line": 350,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "extensionDefinitions",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLEnumType$Builder;",
+            "line": 355,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "value",
+            "desc": "(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/String;Ljava/lang/String;)Lgraphql/schema/GraphQLEnumType$Builder;",
+            "line": 361,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "value",
+            "desc": "(Ljava/lang/String;Ljava/lang/Object;Ljava/lang/String;)Lgraphql/schema/GraphQLEnumType$Builder;",
+            "line": 367,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "value",
+            "desc": "(Ljava/lang/String;Ljava/lang/Object;)Lgraphql/schema/GraphQLEnumType$Builder;",
+            "line": 372,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "value",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLEnumType$Builder;",
+            "line": 379,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "values",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLEnumType$Builder;",
+            "line": 384,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceValues",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLEnumType$Builder;",
+            "line": 389,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "value",
+            "desc": "(Lgraphql/schema/GraphQLEnumValueDefinition;)Lgraphql/schema/GraphQLEnumType$Builder;",
+            "line": 395,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasValue",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 401,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clearValues",
+            "desc": "()Lgraphql/schema/GraphQLEnumType$Builder;",
+            "line": 410,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceDirectives",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLEnumType$Builder;",
+            "line": 418,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withDirectives",
+            "desc": "([Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLEnumType$Builder;",
+            "line": 423,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "withDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLEnumType$Builder;",
+            "line": 428,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective$Builder;)Lgraphql/schema/GraphQLEnumType$Builder;",
+            "line": 433,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "clearDirectives",
+            "desc": "()Lgraphql/schema/GraphQLEnumType$Builder;",
+            "line": 438,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLEnumType$Builder;",
+            "line": 443,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLEnumType$Builder;",
+            "line": 448,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/GraphQLEnumType;",
+            "line": 452,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.DataFetchingFieldSelectionSetImpl$SelectedFieldImpl": {
+        "line": {
+          "covered": 24,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 2
+        },
+        "method": {
+          "covered": 14,
+          "missed": 5
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Lgraphql/normalized/ExecutableNormalizedField;Lgraphql/schema/GraphQLSchema;)V",
+            "line": 312,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkParent",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;)Lgraphql/schema/SelectedField;",
+            "line": 321,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beforeLastSlash",
+            "desc": "(Ljava/lang/String;)Ljava/lang/String;",
+            "line": 328,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 337,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getQualifiedName",
+            "desc": "()Ljava/lang/String;",
+            "line": 342,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFullyQualifiedName",
+            "desc": "()Ljava/lang/String;",
+            "line": 347,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinitions",
+            "desc": "()Ljava/util/List;",
+            "line": 352,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getType",
+            "desc": "()Lgraphql/schema/GraphQLOutputType;",
+            "line": 357,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getObjectTypes",
+            "desc": "()Ljava/util/List;",
+            "line": 362,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getObjectTypeNames",
+            "desc": "()Ljava/util/List;",
+            "line": 367,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArguments",
+            "desc": "()Ljava/util/Map;",
+            "line": 372,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLevel",
+            "desc": "()I",
+            "line": 377,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isConditional",
+            "desc": "()Z",
+            "line": 382,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getAlias",
+            "desc": "()Ljava/lang/String;",
+            "line": 387,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getResultKey",
+            "desc": "()Ljava/lang/String;",
+            "line": 392,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParentField",
+            "desc": "()Lgraphql/schema/SelectedField;",
+            "line": 398,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSelectionSet",
+            "desc": "()Lgraphql/schema/DataFetchingFieldSelectionSet;",
+            "line": 403,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 426,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$new$0",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;)Lgraphql/normalized/ExecutableNormalizedField;",
+            "line": 317,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.ShallowTypeRefCollector$ObjectInterfaceReplaceTarget": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;)V",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLInterfaceType": {
+        "line": {
+          "covered": 56,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 25,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Lgraphql/schema/TypeResolver;Ljava/util/List;Ljava/util/List;Lgraphql/language/InterfaceTypeDefinition;Ljava/util/List;Ljava/util/List;Ljava/util/Comparator;)V",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildDefinitionMap",
+            "desc": "(Ljava/util/List;)Ljava/util/Map;",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinition",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinitions",
+            "desc": "()Ljava/util/List;",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDescription",
+            "desc": "()Ljava/lang/String;",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeResolver",
+            "desc": "()Lgraphql/schema/TypeResolver;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefinition",
+            "desc": "()Lgraphql/language/InterfaceTypeDefinition;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExtensionDefinitions",
+            "desc": "()Ljava/util/List;",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 135,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLDirective;",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 145,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllAppliedDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLAppliedDirective;",
+            "line": 155,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 160,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/schema/GraphQLInterfaceType;",
+            "line": 177,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "copy",
+            "desc": "()Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 184,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 195,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildrenWithTypeReferences",
+            "desc": "()Lgraphql/schema/SchemaElementChildrenContainer;",
+            "line": 204,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;)Lgraphql/schema/GraphQLInterfaceType;",
+            "line": 214,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInterfaces",
+            "desc": "()Ljava/util/List;",
+            "line": 225,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceInterfaces",
+            "desc": "(Ljava/util/List;)V",
+            "line": 232,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newInterface",
+            "desc": "()Lgraphql/schema/GraphQLInterfaceType$Builder;",
+            "line": 253,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newInterface",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;)Lgraphql/schema/GraphQLInterfaceType$Builder;",
+            "line": 257,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;Lgraphql/schema/GraphQLInterfaceType$Builder;)V",
+            "line": 215,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildDefinitionMap$0",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/GraphQLFieldDefinition;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.InputValueWithState": {
+        "line": {
+          "covered": 16,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 10,
+          "missed": 0
+        },
+        "method": {
+          "covered": 12,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/InputValueWithState$State;Ljava/lang/Object;)V",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newLiteralValue",
+            "desc": "(Lgraphql/language/Value;)Lgraphql/schema/InputValueWithState;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newExternalValue",
+            "desc": "(Ljava/lang/Object;)Lgraphql/schema/InputValueWithState;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newInternalValue",
+            "desc": "(Ljava/lang/Object;)Lgraphql/schema/InputValueWithState;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getValue",
+            "desc": "()Ljava/lang/Object;",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isNotSet",
+            "desc": "()Z",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isSet",
+            "desc": "()Z",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isLiteral",
+            "desc": "()Z",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isExternal",
+            "desc": "()Z",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isInternal",
+            "desc": "()Z",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLTypeReference": {
+        "line": {
+          "covered": 8,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "typeRef",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLTypeReference;",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDescription",
+            "desc": "()Ljava/lang/String;",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDefinition",
+            "desc": "()Lgraphql/language/Node;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "copy",
+            "desc": "()Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.DataFetcherFactory": {
+        "line": {
+          "covered": 1,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "get",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;)Lgraphql/schema/DataFetcher;",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.DataFetchingEnvironmentImpl$Builder": {
+        "line": {
+          "covered": 83,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 32,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironmentImpl;)V",
+            "line": 292,
+            "counters": {
+              "line": {
+                "covered": 28,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 292,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "source",
+            "desc": "(Ljava/lang/Object;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 348,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "arguments",
+            "desc": "(Ljava/util/Map;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 353,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "arguments",
+            "desc": "(Ljava/util/function/Supplier;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 357,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "context",
+            "desc": "(Ljava/lang/Object;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 363,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "graphQLContext",
+            "desc": "(Lgraphql/GraphQLContext;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 368,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "localContext",
+            "desc": "(Ljava/lang/Object;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 373,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "root",
+            "desc": "(Ljava/lang/Object;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 378,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 383,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mergedField",
+            "desc": "(Lgraphql/execution/MergedField;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 388,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldType",
+            "desc": "(Lgraphql/schema/GraphQLOutputType;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 393,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parentType",
+            "desc": "(Lgraphql/schema/GraphQLType;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 398,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "graphQLSchema",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 403,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fragmentsByName",
+            "desc": "(Ljava/util/Map;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 408,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executionId",
+            "desc": "(Lgraphql/execution/ExecutionId;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 413,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "selectionSet",
+            "desc": "(Lgraphql/schema/DataFetchingFieldSelectionSet;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 418,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executionStepInfo",
+            "desc": "(Lgraphql/execution/ExecutionStepInfo;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 423,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executionStepInfo",
+            "desc": "(Ljava/util/function/Supplier;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 427,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "dataLoaderRegistry",
+            "desc": "(Lorg/dataloader/DataLoaderRegistry;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 432,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "locale",
+            "desc": "(Ljava/util/Locale;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 437,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "operationDefinition",
+            "desc": "(Lgraphql/language/OperationDefinition;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 442,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "document",
+            "desc": "(Lgraphql/language/Document;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 447,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "variables",
+            "desc": "(Ljava/util/Map;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 452,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "queryDirectives",
+            "desc": "(Lgraphql/execution/directives/QueryDirectives;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 457,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deferredCallContext",
+            "desc": "(Lgraphql/execution/incremental/AlternativeCallContext;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 462,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/DataFetchingEnvironment;",
+            "line": 467,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "dataLoaderDispatchStrategy",
+            "desc": "(Lgraphql/execution/DataLoaderDispatchStrategy;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 471,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "profiler",
+            "desc": "(Lgraphql/Profiler;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 476,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "level",
+            "desc": "(I)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 481,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$executionStepInfo$0",
+            "desc": "(Lgraphql/execution/ExecutionStepInfo;)Lgraphql/execution/ExecutionStepInfo;",
+            "line": 423,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$arguments$0",
+            "desc": "(Ljava/util/Map;)Ljava/util/Map;",
+            "line": 353,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLCodeRegistry$Builder": {
+        "line": {
+          "covered": 73,
+          "missed": 8
+        },
+        "branch": {
+          "covered": 10,
+          "missed": 8
+        },
+        "method": {
+          "covered": 29,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 245,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLCodeRegistry;)V",
+            "line": 245,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "trackChanges",
+            "desc": "()Lgraphql/schema/GraphQLCodeRegistry$Builder;",
+            "line": 271,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasChanged",
+            "desc": "()Z",
+            "line": 280,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "markChanged",
+            "desc": "()Lgraphql/schema/GraphQLCodeRegistry$Builder;",
+            "line": 284,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "markChanged",
+            "desc": "(Z)Lgraphql/schema/GraphQLCodeRegistry$Builder;",
+            "line": 289,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDataFetcher",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/schema/GraphQLFieldDefinition;)Lgraphql/schema/DataFetcher;",
+            "line": 304,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDataFetcher",
+            "desc": "(Lgraphql/schema/FieldCoordinates;Lgraphql/schema/GraphQLFieldDefinition;)Lgraphql/schema/DataFetcher;",
+            "line": 316,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefaultDataFetcherFactory",
+            "desc": "()Lgraphql/schema/DataFetcherFactory;",
+            "line": 323,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasDataFetcher",
+            "desc": "(Lgraphql/schema/FieldCoordinates;)Z",
+            "line": 334,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeResolver",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;)Lgraphql/schema/TypeResolver;",
+            "line": 345,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasTypeResolver",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 356,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeResolver",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;)Lgraphql/schema/TypeResolver;",
+            "line": 367,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "dataFetcher",
+            "desc": "(Lgraphql/schema/FieldCoordinates;Lgraphql/schema/DataFetcher;)Lgraphql/schema/GraphQLCodeRegistry$Builder;",
+            "line": 379,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "dataFetcher",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/DataFetcher;)Lgraphql/schema/GraphQLCodeRegistry$Builder;",
+            "line": 393,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "systemDataFetcher",
+            "desc": "(Lgraphql/schema/FieldCoordinates;Lgraphql/schema/DataFetcher;)Lgraphql/schema/GraphQLCodeRegistry$Builder;",
+            "line": 405,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "dataFetcher",
+            "desc": "(Lgraphql/schema/FieldCoordinates;Lgraphql/schema/DataFetcherFactory;)Lgraphql/schema/GraphQLCodeRegistry$Builder;",
+            "line": 421,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "dataFetcherIfAbsent",
+            "desc": "(Lgraphql/schema/FieldCoordinates;Lgraphql/schema/DataFetcher;)Lgraphql/schema/GraphQLCodeRegistry$Builder;",
+            "line": 441,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "dataFetchers",
+            "desc": "(Ljava/lang/String;Ljava/util/Map;)Lgraphql/schema/GraphQLCodeRegistry$Builder;",
+            "line": 461,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "defaultDataFetcher",
+            "desc": "(Lgraphql/schema/DataFetcherFactory;)Lgraphql/schema/GraphQLCodeRegistry$Builder;",
+            "line": 475,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "dataFetchers",
+            "desc": "(Lgraphql/schema/GraphQLCodeRegistry;)Lgraphql/schema/GraphQLCodeRegistry$Builder;",
+            "line": 480,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "typeResolver",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;Lgraphql/schema/TypeResolver;)Lgraphql/schema/GraphQLCodeRegistry$Builder;",
+            "line": 485,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "typeResolverIfAbsent",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;Lgraphql/schema/TypeResolver;)Lgraphql/schema/GraphQLCodeRegistry$Builder;",
+            "line": 490,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "typeResolver",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;Lgraphql/schema/TypeResolver;)Lgraphql/schema/GraphQLCodeRegistry$Builder;",
+            "line": 498,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "typeResolverIfAbsent",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;Lgraphql/schema/TypeResolver;)Lgraphql/schema/GraphQLCodeRegistry$Builder;",
+            "line": 503,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "typeResolver",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/TypeResolver;)Lgraphql/schema/GraphQLCodeRegistry$Builder;",
+            "line": 511,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "typeResolvers",
+            "desc": "(Lgraphql/schema/GraphQLCodeRegistry;)Lgraphql/schema/GraphQLCodeRegistry$Builder;",
+            "line": 516,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "fieldVisibility",
+            "desc": "(Lgraphql/schema/visibility/GraphqlFieldVisibility;)Lgraphql/schema/GraphQLCodeRegistry$Builder;",
+            "line": 521,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clearDataFetchers",
+            "desc": "()Lgraphql/schema/GraphQLCodeRegistry$Builder;",
+            "line": 526,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clearTypeResolvers",
+            "desc": "()Lgraphql/schema/GraphQLCodeRegistry$Builder;",
+            "line": 531,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/GraphQLCodeRegistry;",
+            "line": 536,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$dataFetchers$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Lgraphql/schema/DataFetcher;)V",
+            "line": 462,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.PropertyFetchingImpl": {
+        "line": {
+          "covered": 165,
+          "missed": 22
+        },
+        "branch": {
+          "covered": 68,
+          "missed": 14
+        },
+        "method": {
+          "covered": 32,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Class;)V",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPropertyValue",
+            "desc": "(Ljava/lang/String;Ljava/lang/Object;Lgraphql/schema/GraphQLType;ZLjava/util/function/Supplier;)Ljava/lang/Object;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 38,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 12,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambdaGetter",
+            "desc": "(Ljava/lang/String;Ljava/lang/Object;)Ljava/util/Optional;",
+            "line": 170,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isNegativelyCached",
+            "desc": "(Lgraphql/schema/PropertyFetchingImpl$CacheKey;)Z",
+            "line": 177,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "putInNegativeCache",
+            "desc": "(Lgraphql/schema/PropertyFetchingImpl$CacheKey;)V",
+            "line": 184,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPropertyViaRecordMethod",
+            "desc": "(Ljava/lang/Object;Ljava/lang/String;Lgraphql/schema/PropertyFetchingImpl$MethodFinder;Ljava/util/function/Supplier;)Ljava/lang/Object;",
+            "line": 194,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPropertyViaGetterMethod",
+            "desc": "(Ljava/lang/Object;Ljava/lang/String;Lgraphql/schema/GraphQLType;Lgraphql/schema/PropertyFetchingImpl$MethodFinder;Ljava/util/function/Supplier;)Ljava/lang/Object;",
+            "line": 199,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPropertyViaGetterUsingPrefix",
+            "desc": "(Ljava/lang/Object;Ljava/lang/String;Ljava/lang/String;Lgraphql/schema/PropertyFetchingImpl$MethodFinder;Ljava/util/function/Supplier;)Ljava/lang/Object;",
+            "line": 211,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "findPubliclyAccessibleMethod",
+            "desc": "(Lgraphql/schema/PropertyFetchingImpl$CacheKey;Ljava/lang/Class;Ljava/lang/String;ZZ)Ljava/lang/reflect/Method;",
+            "line": 225,
+            "counters": {
+              "line": {
+                "covered": 18,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 4
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "findMethodOnPublicInterfaces",
+            "desc": "(Lgraphql/schema/PropertyFetchingImpl$CacheKey;[Ljava/lang/Class;Ljava/lang/String;ZZ)Ljava/lang/reflect/Method;",
+            "line": 260,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isSuitablePublicMethod",
+            "desc": "(Ljava/lang/reflect/Method;Z)Z",
+            "line": 293,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "findRecordMethod",
+            "desc": "(Lgraphql/schema/PropertyFetchingImpl$CacheKey;Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/reflect/Method;",
+            "line": 317,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "findViaSetAccessible",
+            "desc": "(Lgraphql/schema/PropertyFetchingImpl$CacheKey;Ljava/lang/Class;Ljava/lang/String;Z)Ljava/lang/reflect/Method;",
+            "line": 321,
+            "counters": {
+              "line": {
+                "covered": 18,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPropertyViaFieldAccess",
+            "desc": "(Lgraphql/schema/PropertyFetchingImpl$CacheKey;Ljava/lang/Object;Ljava/lang/String;)Ljava/lang/Object;",
+            "line": 353,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "invokeMethod",
+            "desc": "(Ljava/lang/Object;Ljava/util/function/Supplier;Ljava/lang/reflect/Method;Z)Ljava/lang/Object;",
+            "line": 380,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "invokeField",
+            "desc": "(Ljava/lang/Object;Ljava/lang/reflect/Field;)Ljava/lang/Object;",
+            "line": 396,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isBooleanProperty",
+            "desc": "(Lgraphql/schema/GraphQLType;)Z",
+            "line": 404,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 4
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clearReflectionCache",
+            "desc": "()V",
+            "line": 414,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setUseSetAccessible",
+            "desc": "(Z)Z",
+            "line": 421,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setUseLambdaFactory",
+            "desc": "(Z)Z",
+            "line": 425,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setUseNegativeCache",
+            "desc": "(Z)Z",
+            "line": 429,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkCacheKey",
+            "desc": "(Ljava/lang/Object;Ljava/lang/String;)Lgraphql/schema/PropertyFetchingImpl$CacheKey;",
+            "line": 433,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasZeroArgs",
+            "desc": "(Ljava/lang/reflect/Method;)Z",
+            "line": 482,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "takesSingleArgumentTypeAsOnlyArgument",
+            "desc": "(Ljava/lang/reflect/Method;)Z",
+            "line": 486,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mostMethodArgsFirst",
+            "desc": "()Ljava/util/Comparator;",
+            "line": 491,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$findViaSetAccessible$1",
+            "desc": "(Ljava/lang/String;Ljava/lang/reflect/Method;)Z",
+            "line": 334,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$findViaSetAccessible$0",
+            "desc": "(ZLjava/lang/reflect/Method;)Z",
+            "line": 327,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getPropertyValue$3",
+            "desc": "(Lgraphql/schema/PropertyFetchingImpl$CacheKey;ZLjava/lang/Class;Ljava/lang/String;)Ljava/lang/reflect/Method;",
+            "line": 154,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getPropertyValue$2",
+            "desc": "(Lgraphql/schema/PropertyFetchingImpl$CacheKey;ZLjava/lang/Class;Ljava/lang/String;)Ljava/lang/reflect/Method;",
+            "line": 147,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getPropertyValue$1",
+            "desc": "(Lgraphql/schema/PropertyFetchingImpl$CacheKey;ZLjava/lang/Class;Ljava/lang/String;)Ljava/lang/reflect/Method;",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getPropertyValue$0",
+            "desc": "(Lgraphql/schema/PropertyFetchingImpl$CacheKey;Ljava/lang/Class;Ljava/lang/String;)Ljava/lang/reflect/Method;",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.SchemaTransformer$2": {
+        "line": {
+          "covered": 41,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 20,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/SchemaTransformer;Lgraphql/schema/SchemaTransformer$DummyRoot;Ljava/util/Map;Ljava/util/List;Lgraphql/schema/GraphQLTypeVisitor;Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;Ljava/util/Map;)V",
+            "line": 263,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enter",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 266,
+            "counters": {
+              "line": {
+                "covered": 30,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 18,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "leave",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 316,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "backRef",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 321,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$enter$1",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 307,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$enter$0",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;)Ljava/util/List;",
+            "line": 303,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.SchemaTransformer$1": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/SchemaTransformer;Ljava/util/Map;)V",
+            "line": 234,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLTypeReference",
+            "desc": "(Lgraphql/schema/GraphQLTypeReference;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 237,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLTypeVisitorStub": {
+        "line": {
+          "covered": 18,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 18,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 14,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLAppliedDirectiveArgument",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirectiveArgument;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 18,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLAppliedDirective",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirective;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLArgument",
+            "desc": "(Lgraphql/schema/GraphQLArgument;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInterfaceType",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLEnumType",
+            "desc": "(Lgraphql/schema/GraphQLEnumType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLEnumValueDefinition",
+            "desc": "(Lgraphql/schema/GraphQLEnumValueDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputObjectField",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInputObjectType",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 63,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLList",
+            "desc": "(Lgraphql/schema/GraphQLList;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLNonNull",
+            "desc": "(Lgraphql/schema/GraphQLNonNull;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLObjectType",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLScalarType",
+            "desc": "(Lgraphql/schema/GraphQLScalarType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLTypeReference",
+            "desc": "(Lgraphql/schema/GraphQLTypeReference;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLUnionType",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLType",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 97,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLTypeUtil": {
+        "line": {
+          "covered": 48,
+          "missed": 7
+        },
+        "branch": {
+          "covered": 38,
+          "missed": 8
+        },
+        "method": {
+          "covered": 21,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 21,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "simplePrint",
+            "desc": "(Lgraphql/schema/GraphQLType;)Ljava/lang/String;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "simplePrint",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;)Ljava/lang/String;",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isNonNull",
+            "desc": "(Lgraphql/schema/GraphQLType;)Z",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isNullable",
+            "desc": "(Lgraphql/schema/GraphQLType;)Z",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isList",
+            "desc": "(Lgraphql/schema/GraphQLType;)Z",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isWrapped",
+            "desc": "(Lgraphql/schema/GraphQLType;)Z",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isNotWrapped",
+            "desc": "(Lgraphql/schema/GraphQLType;)Z",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isScalar",
+            "desc": "(Lgraphql/schema/GraphQLType;)Z",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEnum",
+            "desc": "(Lgraphql/schema/GraphQLType;)Z",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isLeaf",
+            "desc": "(Lgraphql/schema/GraphQLType;)Z",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isInput",
+            "desc": "(Lgraphql/schema/GraphQLType;)Z",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unwrapOne",
+            "desc": "(Lgraphql/schema/GraphQLType;)Lgraphql/schema/GraphQLType;",
+            "line": 165,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unwrapOneAs",
+            "desc": "(Lgraphql/schema/GraphQLType;)Lgraphql/schema/GraphQLType;",
+            "line": 184,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unwrapAll",
+            "desc": "(Lgraphql/schema/GraphQLType;)Lgraphql/schema/GraphQLUnmodifiedType;",
+            "line": 196,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unwrapAllAs",
+            "desc": "(Lgraphql/schema/GraphQLType;)Lgraphql/schema/GraphQLType;",
+            "line": 210,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unwrapAllImpl",
+            "desc": "(Lgraphql/schema/GraphQLType;)Lgraphql/schema/GraphQLType;",
+            "line": 215,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unwrapNonNull",
+            "desc": "(Lgraphql/schema/GraphQLType;)Lgraphql/schema/GraphQLType;",
+            "line": 234,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unwrapNonNullAs",
+            "desc": "(Lgraphql/schema/GraphQLType;)Lgraphql/schema/GraphQLType;",
+            "line": 252,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unwrapType",
+            "desc": "(Lgraphql/schema/GraphQLType;)Ljava/util/Stack;",
+            "line": 265,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isInterfaceOrUnion",
+            "desc": "(Lgraphql/schema/GraphQLType;)Z",
+            "line": 278,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 4
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isObjectType",
+            "desc": "(Lgraphql/schema/GraphQLType;)Z",
+            "line": 282,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isSystemElement",
+            "desc": "()Ljava/util/function/Predicate;",
+            "line": 293,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isSystemElement$0",
+            "desc": "(Lgraphql/schema/GraphQLNamedSchemaElement;)Z",
+            "line": 294,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLSchema$BuilderWithoutTypes": {
+        "line": {
+          "covered": 10,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)V",
+            "line": 780,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "codeRegistry",
+            "desc": "(Lgraphql/schema/GraphQLCodeRegistry;)Lgraphql/schema/GraphQLSchema$BuilderWithoutTypes;",
+            "line": 787,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "codeRegistry",
+            "desc": "(Lgraphql/schema/GraphQLCodeRegistry$Builder;)Lgraphql/schema/GraphQLSchema$BuilderWithoutTypes;",
+            "line": 792,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLSchema$BuilderWithoutTypes;",
+            "line": 796,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/GraphQLSchema;",
+            "line": 801,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLAppliedDirectiveArgument": {
+        "line": {
+          "covered": 28,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 15,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/InputValueWithState;Lgraphql/schema/GraphQLInputType;Lgraphql/language/Argument;)V",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getType",
+            "desc": "()Lgraphql/schema/GraphQLInputType;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceType",
+            "desc": "(Lgraphql/schema/GraphQLInputType;)V",
+            "line": 63,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasSetValue",
+            "desc": "()Z",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentValue",
+            "desc": "()Lgraphql/schema/InputValueWithState;",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getValue",
+            "desc": "()Ljava/lang/Object;",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDescription",
+            "desc": "()Ljava/lang/String;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDefinition",
+            "desc": "()Lgraphql/language/Argument;",
+            "line": 106,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildrenWithTypeReferences",
+            "desc": "()Lgraphql/schema/SchemaElementChildrenContainer;",
+            "line": 118,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;)Lgraphql/schema/GraphQLAppliedDirectiveArgument;",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "copy",
+            "desc": "()Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/schema/GraphQLAppliedDirectiveArgument;",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newArgument",
+            "desc": "()Lgraphql/schema/GraphQLAppliedDirectiveArgument$Builder;",
+            "line": 168,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newArgument",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirectiveArgument;)Lgraphql/schema/GraphQLAppliedDirectiveArgument$Builder;",
+            "line": 172,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 177,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 182,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;Lgraphql/schema/GraphQLAppliedDirectiveArgument$Builder;)V",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLAppliedDirectiveArgument$Builder": {
+        "line": {
+          "covered": 21,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 9,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 191,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirectiveArgument;)V",
+            "line": 191,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "type",
+            "desc": "(Lgraphql/schema/GraphQLInputType;)Lgraphql/schema/GraphQLAppliedDirectiveArgument$Builder;",
+            "line": 205,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "definition",
+            "desc": "(Lgraphql/language/Argument;)Lgraphql/schema/GraphQLAppliedDirectiveArgument$Builder;",
+            "line": 210,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "valueLiteral",
+            "desc": "(Lgraphql/language/Value;)Lgraphql/schema/GraphQLAppliedDirectiveArgument$Builder;",
+            "line": 222,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "valueProgrammatic",
+            "desc": "(Ljava/lang/Object;)Lgraphql/schema/GraphQLAppliedDirectiveArgument$Builder;",
+            "line": 232,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inputValueWithState",
+            "desc": "(Lgraphql/schema/InputValueWithState;)Lgraphql/schema/GraphQLAppliedDirectiveArgument$Builder;",
+            "line": 237,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clearValue",
+            "desc": "()Lgraphql/schema/GraphQLAppliedDirectiveArgument$Builder;",
+            "line": 247,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/GraphQLAppliedDirectiveArgument;",
+            "line": 254,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.SchemaElementChildrenContainer": {
+        "line": {
+          "covered": 14,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 1
+        },
+        "method": {
+          "covered": 7,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Map;)V",
+            "line": 18,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildOrNull",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/Map;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildrenAsList",
+            "desc": "()Ljava/util/List;",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newSchemaElementChildrenContainer",
+            "desc": "()Lgraphql/schema/SchemaElementChildrenContainer$Builder;",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newSchemaElementChildrenContainer",
+            "desc": "(Ljava/util/Map;)Lgraphql/schema/SchemaElementChildrenContainer$Builder;",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newSchemaElementChildrenContainer",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;)Lgraphql/schema/SchemaElementChildrenContainer$Builder;",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/schema/SchemaElementChildrenContainer;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isEmpty",
+            "desc": "()Z",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLScalarType": {
+        "line": {
+          "covered": 39,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 21,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Lgraphql/schema/Coercing;Ljava/util/List;Ljava/util/List;Lgraphql/language/ScalarTypeDefinition;Ljava/util/List;Ljava/lang/String;)V",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDescription",
+            "desc": "()Ljava/lang/String;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSpecifiedByUrl",
+            "desc": "()Ljava/lang/String;",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCoercing",
+            "desc": "()Lgraphql/schema/Coercing;",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefinition",
+            "desc": "()Lgraphql/language/ScalarTypeDefinition;",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExtensionDefinitions",
+            "desc": "()Ljava/util/List;",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 109,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLDirective;",
+            "line": 119,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 124,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllAppliedDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLAppliedDirective;",
+            "line": 134,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/schema/GraphQLScalarType;",
+            "line": 155,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "copy",
+            "desc": "()Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 168,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 173,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildrenWithTypeReferences",
+            "desc": "()Lgraphql/schema/SchemaElementChildrenContainer;",
+            "line": 180,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;)Lgraphql/schema/GraphQLScalarType;",
+            "line": 188,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "newScalar",
+            "desc": "()Lgraphql/schema/GraphQLScalarType$Builder;",
+            "line": 212,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newScalar",
+            "desc": "(Lgraphql/schema/GraphQLScalarType;)Lgraphql/schema/GraphQLScalarType$Builder;",
+            "line": 216,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;Lgraphql/schema/GraphQLScalarType$Builder;)V",
+            "line": 189,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphqlTypeComparators": {
+        "line": {
+          "covered": 6,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 11,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "sortTypes",
+            "desc": "(Ljava/util/Comparator;Ljava/util/Collection;)Ljava/util/List;",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "asIsOrder",
+            "desc": "()Ljava/util/Comparator;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "byNameAsc",
+            "desc": "()Ljava/util/Comparator;",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$asIsOrder$0",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;Lgraphql/schema/GraphQLSchemaElement;)I",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$0",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;)Ljava/lang/String;",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 13,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLDirective": {
+        "line": {
+          "covered": 41,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 8,
+          "missed": 0
+        },
+        "method": {
+          "covered": 18,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;ZLjava/util/EnumSet;Ljava/util/List;Lgraphql/language/DirectiveDefinition;)V",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isRepeatable",
+            "desc": "()Z",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isNonRepeatable",
+            "desc": "()Z",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArguments",
+            "desc": "()Ljava/util/List;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgument",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLArgument;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validLocations",
+            "desc": "()Ljava/util/EnumSet;",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDescription",
+            "desc": "()Ljava/lang/String;",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefinition",
+            "desc": "()Lgraphql/language/DirectiveDefinition;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/schema/GraphQLDirective;",
+            "line": 122,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "copy",
+            "desc": "()Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 135,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildrenWithTypeReferences",
+            "desc": "()Lgraphql/schema/SchemaElementChildrenContainer;",
+            "line": 145,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;)Lgraphql/schema/GraphQLDirective;",
+            "line": 152,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toAppliedDirective",
+            "desc": "()Lgraphql/schema/GraphQLAppliedDirective;",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newDirective",
+            "desc": "()Lgraphql/schema/GraphQLDirective$Builder;",
+            "line": 188,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLDirective$Builder;",
+            "line": 192,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;Lgraphql/schema/GraphQLDirective$Builder;)V",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.SchemaTraverser$TraverserDelegateListVisitor": {
+        "line": {
+          "covered": 14,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 6,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;)V",
+            "line": 128,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enter",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 135,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "leave",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "backRef",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.InputValueWithState$State": {
+        "line": {
+          "covered": 5,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.PropertyFetchingImpl$CachedLambdaFunction": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/function/Function;)V",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLTypeResolvingVisitor": {
+        "line": {
+          "covered": 18,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 10,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Map;)V",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLObjectType",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLInterfaceType",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLUnionType",
+            "desc": "(Lgraphql/schema/GraphQLUnionType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLTypeReference",
+            "desc": "(Lgraphql/schema/GraphQLTypeReference;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleTypeReference",
+            "desc": "(Lgraphql/schema/GraphQLTypeReference;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitBackRef",
+            "desc": "(Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLUnionType$0",
+            "desc": "(Lgraphql/schema/GraphQLNamedOutputType;)Lgraphql/schema/GraphQLNamedOutputType;",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLInterfaceType$0",
+            "desc": "(Lgraphql/schema/GraphQLNamedOutputType;)Lgraphql/schema/GraphQLNamedOutputType;",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$visitGraphQLObjectType$0",
+            "desc": "(Lgraphql/schema/GraphQLNamedOutputType;)Lgraphql/schema/GraphQLNamedOutputType;",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphqlTypeComparatorRegistry$1": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 13,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getComparator",
+            "desc": "(Lgraphql/schema/GraphqlTypeComparatorEnvironment;)Ljava/util/Comparator;",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphqlTypeComparatorRegistry$2": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getComparator",
+            "desc": "(Lgraphql/schema/GraphqlTypeComparatorEnvironment;)Ljava/util/Comparator;",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.DataFetchingEnvironmentImpl$DFEInternalState": {
+        "line": {
+          "covered": 7,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/DataLoaderDispatchStrategy;Lgraphql/execution/incremental/AlternativeCallContext;Lgraphql/Profiler;)V",
+            "line": 492,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDataLoaderDispatchStrategy",
+            "desc": "()Lgraphql/execution/DataLoaderDispatchStrategy;",
+            "line": 499,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDeferredCallContext",
+            "desc": "()Lgraphql/execution/incremental/AlternativeCallContext;",
+            "line": 503,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getProfiler",
+            "desc": "()Lgraphql/Profiler;",
+            "line": 507,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.SchemaElementChildrenContainer$Builder": {
+        "line": {
+          "covered": 14,
+          "missed": 9
+        },
+        "branch": {
+          "covered": 1,
+          "missed": 1
+        },
+        "method": {
+          "covered": 7,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;)V",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "child",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLSchemaElement;)Lgraphql/schema/SchemaElementChildrenContainer$Builder;",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "children",
+            "desc": "(Ljava/lang/String;Ljava/util/Collection;)Lgraphql/schema/SchemaElementChildrenContainer$Builder;",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "children",
+            "desc": "(Ljava/util/Map;)Lgraphql/schema/SchemaElementChildrenContainer$Builder;",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceChild",
+            "desc": "(Ljava/lang/String;ILgraphql/schema/GraphQLSchemaElement;)Lgraphql/schema/SchemaElementChildrenContainer$Builder;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "removeChild",
+            "desc": "(Ljava/lang/String;I)Lgraphql/schema/SchemaElementChildrenContainer$Builder;",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/SchemaElementChildrenContainer;",
+            "line": 113,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$children$0",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$child$0",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLObjectType$Builder": {
+        "line": {
+          "covered": 66,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 9,
+          "missed": 3
+        },
+        "method": {
+          "covered": 22,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 254,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;)V",
+            "line": 254,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "definition",
+            "desc": "(Lgraphql/language/ObjectTypeDefinition;)Lgraphql/schema/GraphQLObjectType$Builder;",
+            "line": 272,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "extensionDefinitions",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLObjectType$Builder;",
+            "line": 277,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "field",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;)Lgraphql/schema/GraphQLObjectType$Builder;",
+            "line": 282,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "field",
+            "desc": "(Ljava/util/function/UnaryOperator;)Lgraphql/schema/GraphQLObjectType$Builder;",
+            "line": 301,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "field",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition$Builder;)Lgraphql/schema/GraphQLObjectType$Builder;",
+            "line": 316,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fields",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLObjectType$Builder;",
+            "line": 320,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceFields",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLObjectType$Builder;",
+            "line": 326,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clearFields",
+            "desc": "()Lgraphql/schema/GraphQLObjectType$Builder;",
+            "line": 338,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasField",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 343,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withInterface",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;)Lgraphql/schema/GraphQLObjectType$Builder;",
+            "line": 348,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceInterfaces",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLObjectType$Builder;",
+            "line": 354,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withInterface",
+            "desc": "(Lgraphql/schema/GraphQLTypeReference;)Lgraphql/schema/GraphQLObjectType$Builder;",
+            "line": 367,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withInterfaces",
+            "desc": "([Lgraphql/schema/GraphQLInterfaceType;)Lgraphql/schema/GraphQLObjectType$Builder;",
+            "line": 373,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withInterfaces",
+            "desc": "([Lgraphql/schema/GraphQLTypeReference;)Lgraphql/schema/GraphQLObjectType$Builder;",
+            "line": 380,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clearInterfaces",
+            "desc": "()Lgraphql/schema/GraphQLObjectType$Builder;",
+            "line": 392,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "replaceDirectives",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLObjectType$Builder;",
+            "line": 400,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withDirectives",
+            "desc": "([Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLObjectType$Builder;",
+            "line": 405,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "withDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLObjectType$Builder;",
+            "line": 410,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective$Builder;)Lgraphql/schema/GraphQLObjectType$Builder;",
+            "line": 415,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "clearDirectives",
+            "desc": "()Lgraphql/schema/GraphQLObjectType$Builder;",
+            "line": 420,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLObjectType$Builder;",
+            "line": 425,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLObjectType$Builder;",
+            "line": 430,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/GraphQLObjectType;",
+            "line": 434,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.DataFetchingEnvironmentImpl": {
+        "line": {
+          "covered": 76,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 11,
+          "missed": 1
+        },
+        "method": {
+          "covered": 34,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;)V",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 25,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newDataFetchingEnvironment",
+            "desc": "()Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newDataFetchingEnvironment",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newDataFetchingEnvironment",
+            "desc": "(Lgraphql/execution/ExecutionContext;)Lgraphql/schema/DataFetchingEnvironmentImpl$Builder;",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSource",
+            "desc": "()Ljava/lang/Object;",
+            "line": 128,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArguments",
+            "desc": "()Ljava/util/Map;",
+            "line": 133,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "containsArgument",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgument",
+            "desc": "(Ljava/lang/String;)Ljava/lang/Object;",
+            "line": 143,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentOrDefault",
+            "desc": "(Ljava/lang/String;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 148,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getContext",
+            "desc": "()Ljava/lang/Object;",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getGraphQlContext",
+            "desc": "()Lgraphql/GraphQLContext;",
+            "line": 158,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocalContext",
+            "desc": "()Ljava/lang/Object;",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getRoot",
+            "desc": "()Ljava/lang/Object;",
+            "line": 168,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinition",
+            "desc": "()Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 173,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFields",
+            "desc": "()Ljava/util/List;",
+            "line": 178,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getField",
+            "desc": "()Lgraphql/language/Field;",
+            "line": 183,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMergedField",
+            "desc": "()Lgraphql/execution/MergedField;",
+            "line": 188,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldType",
+            "desc": "()Lgraphql/schema/GraphQLOutputType;",
+            "line": 193,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParentType",
+            "desc": "()Lgraphql/schema/GraphQLType;",
+            "line": 198,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getGraphQLSchema",
+            "desc": "()Lgraphql/schema/GraphQLSchema;",
+            "line": 203,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFragmentsByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 208,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExecutionId",
+            "desc": "()Lgraphql/execution/ExecutionId;",
+            "line": 213,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSelectionSet",
+            "desc": "()Lgraphql/schema/DataFetchingFieldSelectionSet;",
+            "line": 218,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getQueryDirectives",
+            "desc": "()Lgraphql/execution/directives/QueryDirectives;",
+            "line": 223,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExecutionStepInfo",
+            "desc": "()Lgraphql/execution/ExecutionStepInfo;",
+            "line": 228,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDataLoader",
+            "desc": "(Ljava/lang/String;)Lorg/dataloader/DataLoader;",
+            "line": 234,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDataLoaderRegistry",
+            "desc": "()Lorg/dataloader/DataLoaderRegistry;",
+            "line": 247,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocale",
+            "desc": "()Ljava/util/Locale;",
+            "line": 252,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOperationDefinition",
+            "desc": "()Lgraphql/language/OperationDefinition;",
+            "line": 257,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDocument",
+            "desc": "()Lgraphql/language/Document;",
+            "line": 262,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getVariables",
+            "desc": "()Ljava/util/Map;",
+            "line": 267,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toInternal",
+            "desc": "()Ljava/lang/Object;",
+            "line": 273,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 278,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLevel",
+            "desc": "()I",
+            "line": 284,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.PropertyDataFetcherHelper": {
+        "line": {
+          "covered": 9,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 13,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getPropertyValue",
+            "desc": "(Ljava/lang/String;Ljava/lang/Object;Lgraphql/schema/GraphQLType;)Ljava/lang/Object;",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPropertyValue",
+            "desc": "(Ljava/lang/String;Ljava/lang/Object;Lgraphql/schema/GraphQLType;Ljava/util/function/Supplier;)Ljava/lang/Object;",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clearReflectionCache",
+            "desc": "()V",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setUseSetAccessible",
+            "desc": "(Z)Z",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setUseLambdaFactory",
+            "desc": "(Z)Z",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setUseNegativeCache",
+            "desc": "(Z)Z",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$0",
+            "desc": "()Ljava/lang/Object;",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.CoercingSerializeException": {
+        "line": {
+          "covered": 5,
+          "missed": 7
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 12,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/Throwable;)V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Throwable;)V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/CoercingSerializeException$Builder;)V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/ErrorClassification;",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "newCoercingSerializeException",
+            "desc": "()Lgraphql/schema/CoercingSerializeException$Builder;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLList": {
+        "line": {
+          "covered": 23,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 7,
+          "missed": 3
+        },
+        "method": {
+          "covered": 11,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "list",
+            "desc": "(Lgraphql/schema/GraphQLType;)Lgraphql/schema/GraphQLList;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLType;)V",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getWrappedType",
+            "desc": "()Lgraphql/schema/GraphQLType;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOriginalWrappedType",
+            "desc": "()Lgraphql/schema/GraphQLType;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "replaceType",
+            "desc": "(Lgraphql/schema/GraphQLType;)V",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEqualTo",
+            "desc": "(Ljava/lang/Object;)Z",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildrenWithTypeReferences",
+            "desc": "()Lgraphql/schema/SchemaElementChildrenContainer;",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;)Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "copy",
+            "desc": "()Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 109,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLSchemaElement": {
+        "line": {
+          "covered": 2,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildrenWithTypeReferences",
+            "desc": "()Lgraphql/schema/SchemaElementChildrenContainer;",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;)Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.CoercingParseValueException$Builder": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/CoercingParseValueException;",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.PropertyDataFetcher": {
+        "line": {
+          "covered": 22,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 11,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/function/Function;)V",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fetching",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/PropertyDataFetcher;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fetching",
+            "desc": "(Ljava/util/function/Function;)Lgraphql/schema/PropertyDataFetcher;",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPropertyName",
+            "desc": "()Ljava/lang/String;",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "get",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Ljava/lang/Object;Ljava/util/function/Supplier;)Ljava/lang/Object;",
+            "line": 119,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "get",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 124,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getImpl",
+            "desc": "(Ljava/lang/Object;Lgraphql/schema/GraphQLOutputType;Ljava/util/function/Supplier;)Ljava/lang/Object;",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clearReflectionCache",
+            "desc": "()V",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setUseSetAccessible",
+            "desc": "(Z)Z",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setUseNegativeCache",
+            "desc": "(Z)Z",
+            "line": 174,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$get$0",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Lgraphql/schema/DataFetchingEnvironment;",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.CoercingParseValueException": {
+        "line": {
+          "covered": 6,
+          "missed": 8
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 12,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/Throwable;)V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Throwable;)V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/Throwable;Lgraphql/language/SourceLocation;)V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/CoercingParseValueException$Builder;)V",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/ErrorType;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newCoercingParseValueException",
+            "desc": "()Lgraphql/schema/CoercingParseValueException$Builder;",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLInputObjectField": {
+        "line": {
+          "covered": 56,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 6,
+          "missed": 0
+        },
+        "method": {
+          "covered": 28,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Lgraphql/schema/GraphQLInputType;Lgraphql/schema/InputValueWithState;Ljava/util/List;Ljava/util/List;Lgraphql/language/InputValueDefinition;Ljava/lang/String;)V",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceType",
+            "desc": "(Lgraphql/schema/GraphQLInputType;)V",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getType",
+            "desc": "()Lgraphql/schema/GraphQLInputType;",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInputFieldDefaultValue",
+            "desc": "()Lgraphql/schema/InputValueWithState;",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInputFieldDefaultValue",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;)Ljava/lang/Object;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasSetDefaultValue",
+            "desc": "()Z",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDescription",
+            "desc": "()Ljava/lang/String;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDeprecationReason",
+            "desc": "()Ljava/lang/String;",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isDeprecated",
+            "desc": "()Z",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefinition",
+            "desc": "()Lgraphql/language/InputValueDefinition;",
+            "line": 133,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 143,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 148,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLDirective;",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 158,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllAppliedDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLAppliedDirective;",
+            "line": 168,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/schema/GraphQLInputObjectField;",
+            "line": 180,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "copy",
+            "desc": "()Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 187,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 193,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 198,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildrenWithTypeReferences",
+            "desc": "()Lgraphql/schema/SchemaElementChildrenContainer;",
+            "line": 207,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;)Lgraphql/schema/GraphQLInputObjectField;",
+            "line": 216,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 243,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inputTypeToStringAvoidingCircularReference",
+            "desc": "(Lgraphql/schema/GraphQLInputType;)Ljava/lang/Object;",
+            "line": 255,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newInputObjectField",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;)Lgraphql/schema/GraphQLInputObjectField$Builder;",
+            "line": 261,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newInputObjectField",
+            "desc": "()Lgraphql/schema/GraphQLInputObjectField$Builder;",
+            "line": 266,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;Lgraphql/schema/GraphQLInputObjectField$Builder;)V",
+            "line": 217,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.PropertyFetchingImpl$CacheKey": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/ClassLoader;Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 443,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 472,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.DataFetcherFactories$1": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/DataFetcher;)V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "get",
+            "desc": "(Lgraphql/schema/DataFetcherFactoryEnvironment;)Lgraphql/schema/DataFetcher;",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "get",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;)Lgraphql/schema/DataFetcher;",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.SingletonPropertyDataFetcher": {
+        "line": {
+          "covered": 9,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "singleton",
+            "desc": "()Lgraphql/schema/LightDataFetcher;",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "singletonFactory",
+            "desc": "()Lgraphql/schema/DataFetcherFactory;",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "get",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Ljava/lang/Object;Ljava/util/function/Supplier;)Ljava/lang/Object;",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "get",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fetchImpl",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Ljava/lang/Object;Ljava/util/function/Supplier;)Ljava/lang/Object;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$get$0",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Lgraphql/schema/DataFetchingEnvironment;",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.CoercingSerializeException$Builder": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/CoercingSerializeException;",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.ShallowTypeRefCollector$InterfaceInterfaceReplaceTarget": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;)V",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLInputObjectType$Builder": {
+        "line": {
+          "covered": 39,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 16,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 260,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;)V",
+            "line": 260,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "definition",
+            "desc": "(Lgraphql/language/InputObjectTypeDefinition;)Lgraphql/schema/GraphQLInputObjectType$Builder;",
+            "line": 276,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "extensionDefinitions",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLInputObjectType$Builder;",
+            "line": 281,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "field",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;)Lgraphql/schema/GraphQLInputObjectType$Builder;",
+            "line": 286,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "field",
+            "desc": "(Ljava/util/function/UnaryOperator;)Lgraphql/schema/GraphQLInputObjectType$Builder;",
+            "line": 305,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "field",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField$Builder;)Lgraphql/schema/GraphQLInputObjectType$Builder;",
+            "line": 320,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fields",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLInputObjectType$Builder;",
+            "line": 324,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceFields",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLInputObjectType$Builder;",
+            "line": 329,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasField",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 335,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clearFields",
+            "desc": "()Lgraphql/schema/GraphQLInputObjectType$Builder;",
+            "line": 344,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "replaceDirectives",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLInputObjectType$Builder;",
+            "line": 352,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withDirectives",
+            "desc": "([Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLInputObjectType$Builder;",
+            "line": 357,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "withDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLInputObjectType$Builder;",
+            "line": 362,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective$Builder;)Lgraphql/schema/GraphQLInputObjectType$Builder;",
+            "line": 367,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "clearDirectives",
+            "desc": "()Lgraphql/schema/GraphQLInputObjectType$Builder;",
+            "line": 372,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLInputObjectType$Builder;",
+            "line": 377,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLInputObjectType$Builder;",
+            "line": 382,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/GraphQLInputObjectType;",
+            "line": 386,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLInputObjectField$Builder": {
+        "line": {
+          "covered": 33,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 14,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 272,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;)V",
+            "line": 272,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "definition",
+            "desc": "(Lgraphql/language/InputValueDefinition;)Lgraphql/schema/GraphQLInputObjectField$Builder;",
+            "line": 292,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deprecate",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLInputObjectField$Builder;",
+            "line": 297,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "type",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType$Builder;)Lgraphql/schema/GraphQLInputObjectField$Builder;",
+            "line": 302,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "type",
+            "desc": "(Lgraphql/schema/GraphQLInputType;)Lgraphql/schema/GraphQLInputObjectField$Builder;",
+            "line": 306,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "defaultValue",
+            "desc": "(Ljava/lang/Object;)Lgraphql/schema/GraphQLInputObjectField$Builder;",
+            "line": 321,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "defaultValueLiteral",
+            "desc": "(Lgraphql/language/Value;)Lgraphql/schema/GraphQLInputObjectField$Builder;",
+            "line": 326,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "defaultValueProgrammatic",
+            "desc": "(Ljava/lang/Object;)Lgraphql/schema/GraphQLInputObjectField$Builder;",
+            "line": 331,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clearDefaultValue",
+            "desc": "()Lgraphql/schema/GraphQLInputObjectField$Builder;",
+            "line": 336,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "replaceDirectives",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLInputObjectField$Builder;",
+            "line": 344,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withDirectives",
+            "desc": "([Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLInputObjectField$Builder;",
+            "line": 349,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "withDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)Lgraphql/schema/GraphQLInputObjectField$Builder;",
+            "line": 354,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective$Builder;)Lgraphql/schema/GraphQLInputObjectField$Builder;",
+            "line": 359,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "clearDirectives",
+            "desc": "()Lgraphql/schema/GraphQLInputObjectField$Builder;",
+            "line": 364,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLInputObjectField$Builder;",
+            "line": 369,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLInputObjectField$Builder;",
+            "line": 374,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/GraphQLInputObjectField;",
+            "line": 378,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.SchemaTransformer$DummyRoot": {
+        "line": {
+          "covered": 76,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 36,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Z)V",
+            "line": 622,
+            "counters": {
+              "line": {
+                "covered": 29,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 24,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLSchemaElement;)V",
+            "line": 662,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "copy",
+            "desc": "()Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 668,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 673,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getChildrenWithTypeReferences",
+            "desc": "()Lgraphql/schema/SchemaElementChildrenContainer;",
+            "line": 678,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;)Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 701,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 721,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "rebuildSchema",
+            "desc": "(Lgraphql/schema/GraphQLCodeRegistry$Builder;Ljava/util/Set;)Lgraphql/schema/GraphQLSchema;",
+            "line": 728,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLEnumValueDefinition": {
+        "line": {
+          "covered": 40,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 22,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/Object;Ljava/lang/String;Ljava/util/List;Ljava/util/List;Lgraphql/language/EnumValueDefinition;)V",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDescription",
+            "desc": "()Ljava/lang/String;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getValue",
+            "desc": "()Ljava/lang/Object;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isDeprecated",
+            "desc": "()Z",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDeprecationReason",
+            "desc": "()Ljava/lang/String;",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLDirective;",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefinition",
+            "desc": "()Lgraphql/language/EnumValueDefinition;",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirectives",
+            "desc": "()Ljava/util/List;",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllAppliedDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAppliedDirective",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLAppliedDirective;",
+            "line": 113,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/schema/GraphQLEnumValueDefinition;",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "copy",
+            "desc": "()Lgraphql/schema/GraphQLSchemaElement;",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "accept",
+            "desc": "(Lgraphql/util/TraverserContext;Lgraphql/schema/GraphQLTypeVisitor;)Lgraphql/util/TraversalControl;",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 143,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildrenWithTypeReferences",
+            "desc": "()Lgraphql/schema/SchemaElementChildrenContainer;",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "withNewChildren",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;)Lgraphql/schema/GraphQLEnumValueDefinition;",
+            "line": 159,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 183,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "newEnumValueDefinition",
+            "desc": "()Lgraphql/schema/GraphQLEnumValueDefinition$Builder;",
+            "line": 189,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newEnumValueDefinition",
+            "desc": "(Lgraphql/schema/GraphQLEnumValueDefinition;)Lgraphql/schema/GraphQLEnumValueDefinition$Builder;",
+            "line": 193,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$withNewChildren$0",
+            "desc": "(Lgraphql/schema/SchemaElementChildrenContainer;Lgraphql/schema/GraphQLEnumValueDefinition$Builder;)V",
+            "line": 159,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.GraphQLDirective$Builder": {
+        "line": {
+          "covered": 38,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 14,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 197,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)V",
+            "line": 197,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "repeatable",
+            "desc": "(Z)Lgraphql/schema/GraphQLDirective$Builder;",
+            "line": 214,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validLocations",
+            "desc": "([Lgraphql/introspection/Introspection$DirectiveLocation;)Lgraphql/schema/GraphQLDirective$Builder;",
+            "line": 219,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validLocation",
+            "desc": "(Lgraphql/introspection/Introspection$DirectiveLocation;)Lgraphql/schema/GraphQLDirective$Builder;",
+            "line": 224,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clearValidLocations",
+            "desc": "()Lgraphql/schema/GraphQLDirective$Builder;",
+            "line": 229,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "argument",
+            "desc": "(Lgraphql/schema/GraphQLArgument;)Lgraphql/schema/GraphQLDirective$Builder;",
+            "line": 234,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceArguments",
+            "desc": "(Ljava/util/List;)Lgraphql/schema/GraphQLDirective$Builder;",
+            "line": 240,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "argument",
+            "desc": "(Ljava/util/function/UnaryOperator;)Lgraphql/schema/GraphQLDirective$Builder;",
+            "line": 262,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "argument",
+            "desc": "(Lgraphql/schema/GraphQLArgument$Builder;)Lgraphql/schema/GraphQLDirective$Builder;",
+            "line": 276,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clearArguments",
+            "desc": "()Lgraphql/schema/GraphQLDirective$Builder;",
+            "line": 285,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "definition",
+            "desc": "(Lgraphql/language/DirectiveDefinition;)Lgraphql/schema/GraphQLDirective$Builder;",
+            "line": 291,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "name",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLDirective$Builder;",
+            "line": 299,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLDirective$Builder;",
+            "line": 304,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/GraphQLDirective;",
+            "line": 308,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.extensions.ExtensionsMerger": {
+        "line": {
+          "covered": 1,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.extensions.ExtensionsBuilder": {
+        "line": {
+          "covered": 30,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 12,
+          "missed": 0
+        },
+        "method": {
+          "covered": 9,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/extensions/ExtensionsMerger;)V",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newExtensionsBuilder",
+            "desc": "()Lgraphql/extensions/ExtensionsBuilder;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newExtensionsBuilder",
+            "desc": "(Lgraphql/extensions/ExtensionsMerger;)Lgraphql/extensions/ExtensionsBuilder;",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChangeCount",
+            "desc": "()I",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addValues",
+            "desc": "(Ljava/util/Map;)Lgraphql/extensions/ExtensionsBuilder;",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addValue",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;)Lgraphql/extensions/ExtensionsBuilder;",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setExtensions",
+            "desc": "(Lgraphql/ExecutionResult;)Lgraphql/ExecutionResult;",
+            "line": 123,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$setExtensions$0",
+            "desc": "(Ljava/util/Map;Lgraphql/ExecutionResult$Builder;)V",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.extensions.DefaultExtensionsMerger": {
+        "line": {
+          "covered": 30,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 15,
+          "missed": 3
+        },
+        "method": {
+          "covered": 6,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "merge",
+            "desc": "(Ljava/util/Map;Ljava/util/Map;)Ljava/util/Map;",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 19,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 9,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mergeObjects",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "appendLists",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/util/List;",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mapCast",
+            "desc": "(Ljava/lang/Object;)Ljava/util/Map;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "listCast",
+            "desc": "(Ljava/lang/Object;)Ljava/util/Collection;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.incremental.NormalizedDeferredExecution": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/Set;)V",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLabel",
+            "desc": "()Ljava/lang/String;",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPossibleTypes",
+            "desc": "()Ljava/util/Set;",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.MultiSourceReader$Builder": {
+        "line": {
+          "covered": 19,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 274,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "reader",
+            "desc": "(Ljava/io/Reader;Ljava/lang/String;)Lgraphql/parser/MultiSourceReader$Builder;",
+            "line": 281,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "string",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/parser/MultiSourceReader$Builder;",
+            "line": 290,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "trackData",
+            "desc": "(Z)Lgraphql/parser/MultiSourceReader$Builder;",
+            "line": 299,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/parser/MultiSourceReader;",
+            "line": 305,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.CommentParser": {
+        "line": {
+          "covered": 96,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 31,
+          "missed": 9
+        },
+        "method": {
+          "covered": 29,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/parser/NodeToRuleCapturingParser$ParserContext;)V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getBeginningOfBlockComment",
+            "desc": "(Lgraphql/language/Node;Ljava/lang/String;)Ljava/util/Optional;",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getEndOfBlockComments",
+            "desc": "(Lgraphql/language/Node;Ljava/lang/String;)Ljava/util/List;",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTrailingComment",
+            "desc": "(Lgraphql/language/Node;)Ljava/util/Optional;",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLeadingComments",
+            "desc": "(Lgraphql/language/Node;)Ljava/util/List;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCommentsAfterDescription",
+            "desc": "(Lgraphql/language/Node;)Ljava/util/List;",
+            "line": 135,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCommentOnFirstLineOfDocument",
+            "desc": "(Lgraphql/language/Document;)Ljava/util/Optional;",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCommentsAfterAllDefinitions",
+            "desc": "(Lgraphql/language/Document;)Ljava/util/List;",
+            "line": 173,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCommentOnChannel",
+            "desc": "(Ljava/util/List;Ljava/util/function/Predicate;)Ljava/util/List;",
+            "line": 191,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "searchTokenToLeft",
+            "desc": "(Lorg/antlr/v4/runtime/Token;Ljava/lang/String;)Ljava/util/Optional;",
+            "line": 215,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$8",
+            "desc": "(Lorg/antlr/v4/runtime/Token;)Z",
+            "line": 243,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$9",
+            "desc": "(Ljava/util/List;)Ljava/lang/Boolean;",
+            "line": 244,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$10",
+            "desc": "(Lorg/antlr/v4/runtime/Token;)Z",
+            "line": 244,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$7",
+            "desc": "(Lorg/antlr/v4/runtime/Token;)Z",
+            "line": 240,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$4",
+            "desc": "(Lorg/antlr/v4/runtime/Token;)Z",
+            "line": 236,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$5",
+            "desc": "(Ljava/util/List;)Ljava/lang/Boolean;",
+            "line": 237,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$6",
+            "desc": "(Lorg/antlr/v4/runtime/Token;)Z",
+            "line": 237,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$1",
+            "desc": "(Lorg/antlr/v4/runtime/Token;)Z",
+            "line": 231,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$2",
+            "desc": "(Ljava/util/List;)Ljava/lang/Boolean;",
+            "line": 232,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$3",
+            "desc": "(Lorg/antlr/v4/runtime/Token;)Z",
+            "line": 232,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$0",
+            "desc": "(Lorg/antlr/v4/runtime/Token;)Z",
+            "line": 228,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$getCommentsAfterAllDefinitions$0",
+            "desc": "(Lorg/antlr/v4/runtime/Token;)Z",
+            "line": 180,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getCommentsAfterAllDefinitions$1",
+            "desc": "(Ljava/util/List;)Ljava/lang/Boolean;",
+            "line": 181,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getCommentsAfterAllDefinitions$2",
+            "desc": "(Lorg/antlr/v4/runtime/Token;)Z",
+            "line": 181,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getEndOfBlockComments$1",
+            "desc": "(Ljava/util/List;)Ljava/util/List;",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getEndOfBlockComments$0",
+            "desc": "(Lorg/antlr/v4/runtime/Token;)Ljava/util/List;",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getBeginningOfBlockComment$3",
+            "desc": "(Ljava/util/List;)Ljava/util/Optional;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getBeginningOfBlockComment$2",
+            "desc": "(Ljava/util/List;)Ljava/util/List;",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getBeginningOfBlockComment$1",
+            "desc": "(Lorg/antlr/v4/runtime/Token;)Ljava/util/List;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getBeginningOfBlockComment$0",
+            "desc": "(Ljava/lang/String;Lorg/antlr/v4/runtime/Token;)Z",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.UnicodeUtil": {
+        "line": {
+          "covered": 43,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 44,
+          "missed": 0
+        },
+        "method": {
+          "covered": 9,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "parseAndWriteUnicode",
+            "desc": "(Lgraphql/i18n/I18n;Ljava/io/StringWriter;Ljava/lang/String;ILgraphql/language/SourceLocation;)I",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 24,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 18,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "offendingToken",
+            "desc": "(Ljava/lang/String;II)Ljava/lang/String;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getEndIndexExclusive",
+            "desc": "(Lgraphql/i18n/I18n;Ljava/lang/String;ILgraphql/language/SourceLocation;)I",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isValidUnicodeCodePoint",
+            "desc": "(I)Z",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEscapedUnicode",
+            "desc": "(Ljava/lang/String;I)Z",
+            "line": 97,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isLeadingSurrogateValue",
+            "desc": "(I)Z",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isTrailingSurrogateValue",
+            "desc": "(I)Z",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "writeCodePoint",
+            "desc": "(Ljava/io/StringWriter;I)V",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isBracedEscape",
+            "desc": "(Ljava/lang/String;I)Z",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.InvalidSyntaxException": {
+        "line": {
+          "covered": 12,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/SourceLocation;Ljava/lang/String;Ljava/lang/String;Ljava/lang/Exception;)V",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toInvalidSyntaxError",
+            "desc": "()Lgraphql/InvalidSyntaxError;",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMessage",
+            "desc": "()Ljava/lang/String;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocation",
+            "desc": "()Lgraphql/language/SourceLocation;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSourcePreview",
+            "desc": "()Ljava/lang/String;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOffendingToken",
+            "desc": "()Ljava/lang/String;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.ParserOptions$Builder": {
+        "line": {
+          "covered": 44,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 13,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 328,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/parser/ParserOptions;)V",
+            "line": 328,
+            "counters": {
+              "line": {
+                "covered": 21,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "captureIgnoredChars",
+            "desc": "(Z)Lgraphql/parser/ParserOptions$Builder;",
+            "line": 355,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "captureSourceLocation",
+            "desc": "(Z)Lgraphql/parser/ParserOptions$Builder;",
+            "line": 360,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "captureLineComments",
+            "desc": "(Z)Lgraphql/parser/ParserOptions$Builder;",
+            "line": 365,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "readerTrackData",
+            "desc": "(Z)Lgraphql/parser/ParserOptions$Builder;",
+            "line": 370,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "maxCharacters",
+            "desc": "(I)Lgraphql/parser/ParserOptions$Builder;",
+            "line": 375,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "maxTokens",
+            "desc": "(I)Lgraphql/parser/ParserOptions$Builder;",
+            "line": 380,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "maxWhitespaceTokens",
+            "desc": "(I)Lgraphql/parser/ParserOptions$Builder;",
+            "line": 385,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "maxRuleDepth",
+            "desc": "(I)Lgraphql/parser/ParserOptions$Builder;",
+            "line": 390,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "redactTokenParserErrorMessages",
+            "desc": "(Z)Lgraphql/parser/ParserOptions$Builder;",
+            "line": 395,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parsingListener",
+            "desc": "(Lgraphql/parser/ParsingListener;)Lgraphql/parser/ParserOptions$Builder;",
+            "line": 400,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/parser/ParserOptions;",
+            "line": 405,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.NodeToRuleCapturingParser": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAntlrToLanguage",
+            "desc": "(Lorg/antlr/v4/runtime/CommonTokenStream;Lgraphql/parser/MultiSourceReader;Lgraphql/parser/ParserEnvironment;)Lgraphql/parser/GraphqlAntlrToLanguage;",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParserContext",
+            "desc": "()Lgraphql/parser/NodeToRuleCapturingParser$ParserContext;",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.GraphqlAntlrToLanguage": {
+        "line": {
+          "covered": 520,
+          "missed": 14
+        },
+        "branch": {
+          "covered": 178,
+          "missed": 16
+        },
+        "method": {
+          "covered": 64,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lorg/antlr/v4/runtime/CommonTokenStream;Lgraphql/parser/MultiSourceReader;Lgraphql/parser/ParserOptions;Lgraphql/i18n/I18n;Ljava/util/Map;)V",
+            "line": 97,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParserOptions",
+            "desc": "()Lgraphql/parser/ParserOptions;",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createDocument",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$DocumentContext;)Lgraphql/language/Document;",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createDefinition",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$DefinitionContext;)Lgraphql/language/Definition;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createOperationDefinition",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$OperationDefinitionContext;)Lgraphql/language/OperationDefinition;",
+            "line": 135,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseOperation",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$OperationTypeContext;)Lgraphql/language/OperationDefinition$Operation;",
+            "line": 152,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createFragmentSpread",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$FragmentSpreadContext;)Lgraphql/language/FragmentSpread;",
+            "line": 165,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createVariableDefinitions",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$VariableDefinitionsContext;)Ljava/util/List;",
+            "line": 172,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createVariableDefinition",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$VariableDefinitionContext;)Lgraphql/language/VariableDefinition;",
+            "line": 179,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createFragmentDefinition",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$FragmentDefinitionContext;)Lgraphql/language/FragmentDefinition;",
+            "line": 193,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createSelectionSet",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$SelectionSetContext;)Lgraphql/language/SelectionSet;",
+            "line": 204,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createField",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$FieldContext;)Lgraphql/language/Field;",
+            "line": 228,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createInlineFragment",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$InlineFragmentContext;)Lgraphql/language/InlineFragment;",
+            "line": 243,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createTypeSystemDefinition",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$TypeSystemDefinitionContext;)Lgraphql/language/SDLDefinition;",
+            "line": 256,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createTypeSystemExtension",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$TypeSystemExtensionContext;)Lgraphql/language/SDLDefinition;",
+            "line": 268,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createTypeExtension",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$TypeExtensionContext;)Lgraphql/language/TypeDefinition;",
+            "line": 278,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 11,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createTypeDefinition",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$TypeDefinitionContext;)Lgraphql/language/TypeDefinition;",
+            "line": 301,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 11,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createType",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$TypeContext;)Lgraphql/language/Type;",
+            "line": 326,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createTypeName",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$TypeNameContext;)Lgraphql/language/TypeName;",
+            "line": 338,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createNonNullType",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$NonNullTypeContext;)Lgraphql/language/NonNullType;",
+            "line": 345,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createListType",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$ListTypeContext;)Lgraphql/language/ListType;",
+            "line": 358,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createArgument",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$ArgumentContext;)Lgraphql/language/Argument;",
+            "line": 365,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createArguments",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$ArgumentsContext;)Ljava/util/List;",
+            "line": 373,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createDirectives",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$DirectivesContext;)Ljava/util/List;",
+            "line": 381,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createDirective",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$DirectiveContext;)Lgraphql/language/Directive;",
+            "line": 388,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createSchemaDefinition",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$SchemaDefinitionContext;)Lgraphql/language/SchemaDefinition;",
+            "line": 396,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "creationSchemaExtension",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$SchemaExtensionContext;)Lgraphql/language/SDLDefinition;",
+            "line": 405,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createOperationTypeDefinition",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$OperationTypeDefinitionContext;)Lgraphql/language/OperationTypeDefinition;",
+            "line": 422,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createScalarTypeDefinition",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$ScalarTypeDefinitionContext;)Lgraphql/language/ScalarTypeDefinition;",
+            "line": 430,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createScalarTypeExtensionDefinition",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$ScalarTypeExtensionDefinitionContext;)Lgraphql/language/ScalarTypeExtensionDefinition;",
+            "line": 439,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createObjectTypeDefinition",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$ObjectTypeDefinitionContext;)Lgraphql/language/ObjectTypeDefinition;",
+            "line": 447,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createObjectTypeExtensionDefinition",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$ObjectTypeExtensionDefinitionContext;)Lgraphql/language/ObjectTypeExtensionDefinition;",
+            "line": 462,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createFieldDefinitions",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$FieldsDefinitionContext;)Ljava/util/List;",
+            "line": 476,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createFieldDefinitions",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$ExtensionFieldsDefinitionContext;)Ljava/util/List;",
+            "line": 483,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createFieldDefinition",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$FieldDefinitionContext;)Lgraphql/language/FieldDefinition;",
+            "line": 491,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createInputValueDefinitions",
+            "desc": "(Ljava/util/List;)Ljava/util/List;",
+            "line": 504,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createInputValueDefinition",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$InputValueDefinitionContext;)Lgraphql/language/InputValueDefinition;",
+            "line": 508,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createInterfaceTypeDefinition",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$InterfaceTypeDefinitionContext;)Lgraphql/language/InterfaceTypeDefinition;",
+            "line": 521,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createInterfaceTypeExtensionDefinition",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$InterfaceTypeExtensionDefinitionContext;)Lgraphql/language/InterfaceTypeExtensionDefinition;",
+            "line": 534,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createUnionTypeDefinition",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$UnionTypeDefinitionContext;)Lgraphql/language/UnionTypeDefinition;",
+            "line": 546,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createUnionTypeExtensionDefinition",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$UnionTypeExtensionDefinitionContext;)Lgraphql/language/UnionTypeExtensionDefinition;",
+            "line": 565,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createEnumTypeDefinition",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$EnumTypeDefinitionContext;)Lgraphql/language/EnumTypeDefinition;",
+            "line": 582,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createEnumTypeExtensionDefinition",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$EnumTypeExtensionDefinitionContext;)Lgraphql/language/EnumTypeExtensionDefinition;",
+            "line": 595,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createEnumValueDefinition",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$EnumValueDefinitionContext;)Lgraphql/language/EnumValueDefinition;",
+            "line": 607,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createInputObjectTypeDefinition",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$InputObjectTypeDefinitionContext;)Lgraphql/language/InputObjectTypeDefinition;",
+            "line": 616,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createInputObjectTypeExtensionDefinition",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$InputObjectTypeExtensionDefinitionContext;)Lgraphql/language/InputObjectTypeExtensionDefinition;",
+            "line": 628,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createDirectiveDefinition",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$DirectiveDefinitionContext;)Lgraphql/language/DirectiveDefinition;",
+            "line": 639,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createDirectiveLocation",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$DirectiveLocationContext;)Lgraphql/language/DirectiveLocation;",
+            "line": 660,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createValue",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$ValueWithVariableContext;)Lgraphql/language/Value;",
+            "line": 667,
+            "counters": {
+              "line": {
+                "covered": 51,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 21,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createValue",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$ValueContext;)Lgraphql/language/Value;",
+            "line": 727,
+            "counters": {
+              "line": {
+                "covered": 44,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 19,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "quotedString",
+            "desc": "(Lorg/antlr/v4/runtime/tree/TerminalNode;)Ljava/lang/String;",
+            "line": 777,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addCommonData",
+            "desc": "(Lgraphql/language/NodeBuilder;Lorg/antlr/v4/runtime/ParserRuleContext;)V",
+            "line": 788,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addIgnoredChars",
+            "desc": "(Lorg/antlr/v4/runtime/ParserRuleContext;Lgraphql/language/NodeBuilder;)V",
+            "line": 797,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mapTokenToIgnoredChar",
+            "desc": "(Ljava/util/List;)Ljava/util/List;",
+            "line": 814,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createIgnoredChar",
+            "desc": "(Lorg/antlr/v4/runtime/Token;)Lgraphql/language/IgnoredChar;",
+            "line": 822,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newDescription",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$DescriptionContext;)Lgraphql/language/Description;",
+            "line": 847,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSourceLocation",
+            "desc": "(Lorg/antlr/v4/runtime/ParserRuleContext;)Lgraphql/language/SourceLocation;",
+            "line": 866,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSourceLocation",
+            "desc": "(Lorg/antlr/v4/runtime/Token;)Lgraphql/language/SourceLocation;",
+            "line": 870,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getComments",
+            "desc": "(Lorg/antlr/v4/runtime/ParserRuleContext;)Ljava/util/List;",
+            "line": 878,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCommentOnChannel",
+            "desc": "(Ljava/util/List;)Ljava/util/List;",
+            "line": 895,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getImplementz",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$ImplementsInterfacesContext;)Ljava/util/List;",
+            "line": 921,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "captureRuleContext",
+            "desc": "(Lgraphql/language/Node;Lorg/antlr/v4/runtime/ParserRuleContext;)Lgraphql/language/Node;",
+            "line": 931,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$createSelectionSet$0",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser$SelectionContext;)Lgraphql/language/Selection;",
+            "line": 210,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.Parser$2$1": {
+        "line": {
+          "covered": 2,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 1,
+          "missed": 5
+        },
+        "method": {
+          "covered": 2,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/parser/Parser$2;Lorg/antlr/v4/runtime/Token;)V",
+            "line": 394,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getText",
+            "desc": "()Ljava/lang/String;",
+            "line": 397,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLine",
+            "desc": "()I",
+            "line": 402,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getCharPositionInLine",
+            "desc": "()I",
+            "line": 407,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.StringValueParsing": {
+        "line": {
+          "covered": 80,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 50,
+          "missed": 2
+        },
+        "method": {
+          "covered": 5,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "parseTripleQuotedString",
+            "desc": "(Ljava/lang/String;)Ljava/lang/String;",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "removeIndentation",
+            "desc": "(Ljava/lang/String;)Ljava/lang/String;",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 39,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 30,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "leadingWhitespace",
+            "desc": "(Ljava/lang/String;)I",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "containsOnlyWhiteSpace",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseSingleQuotedString",
+            "desc": "(Lgraphql/i18n/I18n;Ljava/lang/String;Lgraphql/language/SourceLocation;)Ljava/lang/String;",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 29,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 13,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.MultiSourceReader$SourceAndLine": {
+        "line": {
+          "covered": 5,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSourceName",
+            "desc": "()Ljava/lang/String;",
+            "line": 106,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLine",
+            "desc": "()I",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.ParserEnvironment$Builder$1": {
+        "line": {
+          "covered": 4,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/parser/ParserEnvironment$Builder;Lgraphql/i18n/I18n;)V",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDocument",
+            "desc": "()Ljava/io/Reader;",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParserOptions",
+            "desc": "()Lgraphql/parser/ParserOptions;",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocale",
+            "desc": "()Ljava/util/Locale;",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getI18N",
+            "desc": "()Lgraphql/i18n/I18n;",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.MultiSourceReader": {
+        "line": {
+          "covered": 94,
+          "missed": 8
+        },
+        "branch": {
+          "covered": 37,
+          "missed": 5
+        },
+        "method": {
+          "covered": 15,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "lineNumberReaderEOSIsTerminator",
+            "desc": "()Z",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/parser/MultiSourceReader$Builder;)V",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "read",
+            "desc": "([CII)I",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "trackData",
+            "desc": "([CII)V",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "calcLineNumber",
+            "desc": "()I",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSourceAndLineFromOverallLine",
+            "desc": "(I)Lgraphql/parser/MultiSourceReader$SourceAndLine;",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 26,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 11,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLineNumber",
+            "desc": "()I",
+            "line": 180,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSourceName",
+            "desc": "()Ljava/lang/String;",
+            "line": 195,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOverallLineNumber",
+            "desc": "()I",
+            "line": 210,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getData",
+            "desc": "()Ljava/util/List;",
+            "line": 214,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "close",
+            "desc": "()V",
+            "line": 231,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newMultiSourceReader",
+            "desc": "()Lgraphql/parser/MultiSourceReader$Builder;",
+            "line": 270,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getSourceName$0",
+            "desc": "()Ljava/lang/String;",
+            "line": 196,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getLineNumber$0",
+            "desc": "()Ljava/lang/Integer;",
+            "line": 181,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.Parser$1": {
+        "line": {
+          "covered": 10,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 1
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/parser/MultiSourceReader;Lgraphql/parser/ParserEnvironment;)V",
+            "line": 326,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "syntaxError",
+            "desc": "(Lorg/antlr/v4/runtime/Recognizer;Ljava/lang/Object;IILjava/lang/String;Lorg/antlr/v4/runtime/RecognitionException;)V",
+            "line": 329,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.Parser$2": {
+        "line": {
+          "covered": 15,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 1
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/parser/Parser;ILgraphql/parser/ParserEnvironment;Lgraphql/parser/MultiSourceReader;Lgraphql/parser/ParsingListener;I)V",
+            "line": 366,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enterEveryRule",
+            "desc": "(Lorg/antlr/v4/runtime/ParserRuleContext;)V",
+            "line": 373,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "exitEveryRule",
+            "desc": "(Lorg/antlr/v4/runtime/ParserRuleContext;)V",
+            "line": 387,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitTerminal",
+            "desc": "(Lorg/antlr/v4/runtime/tree/TerminalNode;)V",
+            "line": 393,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.SafeTokenReader": {
+        "line": {
+          "covered": 18,
+          "missed": 10
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 5
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/io/Reader;ILjava/util/function/Consumer;)V",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkHowMany",
+            "desc": "(II)I",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "read",
+            "desc": "([CII)I",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "read",
+            "desc": "()I",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "read",
+            "desc": "(Ljava/nio/CharBuffer;)I",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "read",
+            "desc": "([C)I",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "close",
+            "desc": "()V",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "skip",
+            "desc": "(J)J",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "ready",
+            "desc": "()Z",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "markSupported",
+            "desc": "()Z",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mark",
+            "desc": "(I)V",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "reset",
+            "desc": "()V",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.ParserEnvironment$Builder": {
+        "line": {
+          "covered": 13,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "document",
+            "desc": "(Ljava/io/Reader;)Lgraphql/parser/ParserEnvironment$Builder;",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "document",
+            "desc": "(Ljava/lang/String;)Lgraphql/parser/ParserEnvironment$Builder;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parserOptions",
+            "desc": "(Lgraphql/parser/ParserOptions;)Lgraphql/parser/ParserEnvironment$Builder;",
+            "line": 63,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "locale",
+            "desc": "(Ljava/util/Locale;)Lgraphql/parser/ParserEnvironment$Builder;",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/parser/ParserEnvironment;",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.ExtendedBailStrategy": {
+        "line": {
+          "covered": 27,
+          "missed": 7
+        },
+        "branch": {
+          "covered": 7,
+          "missed": 3
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/parser/MultiSourceReader;Lgraphql/parser/ParserEnvironment;)V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "recover",
+            "desc": "(Lorg/antlr/v4/runtime/Parser;Lorg/antlr/v4/runtime/RecognitionException;)V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "recoverInline",
+            "desc": "(Lorg/antlr/v4/runtime/Parser;)Lorg/antlr/v4/runtime/Token;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkMoreTokensException",
+            "desc": "(Lorg/antlr/v4/runtime/Token;)Lgraphql/parser/InvalidSyntaxException;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkException",
+            "desc": "(Lorg/antlr/v4/runtime/Parser;Lorg/antlr/v4/runtime/RecognitionException;)Lgraphql/parser/InvalidSyntaxException;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.ParserEnvironment": {
+        "line": {
+          "covered": 1,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "newParserEnvironment",
+            "desc": "()Lgraphql/parser/ParserEnvironment$Builder;",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.SafeTokenSource": {
+        "line": {
+          "covered": 17,
+          "missed": 8
+        },
+        "branch": {
+          "covered": 5,
+          "missed": 1
+        },
+        "method": {
+          "covered": 3,
+          "missed": 6
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lorg/antlr/v4/runtime/TokenSource;IILjava/util/function/BiConsumer;)V",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "nextToken",
+            "desc": "()Lorg/antlr/v4/runtime/Token;",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "callbackIfMaxExceeded",
+            "desc": "(IILorg/antlr/v4/runtime/Token;)V",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLine",
+            "desc": "()I",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getCharPositionInLine",
+            "desc": "()I",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getInputStream",
+            "desc": "()Lorg/antlr/v4/runtime/CharStream;",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getSourceName",
+            "desc": "()Ljava/lang/String;",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "setTokenFactory",
+            "desc": "(Lorg/antlr/v4/runtime/TokenFactory;)V",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getTokenFactory",
+            "desc": "()Lorg/antlr/v4/runtime/TokenFactory;",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.MultiSourceReader$SourcePart": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 6,
+          "missed": 2
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 244,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLineNumber",
+            "desc": "()I",
+            "line": 257,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.ParserOptions": {
+        "line": {
+          "covered": 68,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 20,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "getDefaultParserOptions",
+            "desc": "()Lgraphql/parser/ParserOptions;",
+            "line": 105,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setDefaultParserOptions",
+            "desc": "(Lgraphql/parser/ParserOptions;)V",
+            "line": 123,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefaultOperationParserOptions",
+            "desc": "()Lgraphql/parser/ParserOptions;",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setDefaultOperationParserOptions",
+            "desc": "(Lgraphql/parser/ParserOptions;)V",
+            "line": 152,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefaultSdlParserOptions",
+            "desc": "()Lgraphql/parser/ParserOptions;",
+            "line": 169,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setDefaultSdlParserOptions",
+            "desc": "(Lgraphql/parser/ParserOptions;)V",
+            "line": 184,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/parser/ParserOptions$Builder;)V",
+            "line": 198,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isCaptureIgnoredChars",
+            "desc": "()Z",
+            "line": 218,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isCaptureSourceLocation",
+            "desc": "()Z",
+            "line": 231,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isCaptureLineComments",
+            "desc": "()Z",
+            "line": 245,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isReaderTrackData",
+            "desc": "()Z",
+            "line": 254,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMaxCharacters",
+            "desc": "()I",
+            "line": 265,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMaxTokens",
+            "desc": "()I",
+            "line": 277,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMaxWhitespaceTokens",
+            "desc": "()I",
+            "line": 288,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMaxRuleDepth",
+            "desc": "()I",
+            "line": 299,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isRedactTokenParserErrorMessages",
+            "desc": "()Z",
+            "line": 309,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParsingListener",
+            "desc": "()Lgraphql/parser/ParsingListener;",
+            "line": 313,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/parser/ParserOptions;",
+            "line": 317,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newParserOptions",
+            "desc": "()Lgraphql/parser/ParserOptions$Builder;",
+            "line": 323,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 33,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.NodeToRuleCapturingParser$ParserContext": {
+        "line": {
+          "covered": 5,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTokens",
+            "desc": "()Lorg/antlr/v4/runtime/CommonTokenStream;",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNodeToRuleMap",
+            "desc": "()Ljava/util/Map;",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.AntlrHelper": {
+        "line": {
+          "covered": 16,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 6,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 11,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "createSourceLocation",
+            "desc": "(Lgraphql/parser/MultiSourceReader;II)Lgraphql/language/SourceLocation;",
+            "line": 18,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createSourceLocation",
+            "desc": "(Lgraphql/parser/MultiSourceReader;Lorg/antlr/v4/runtime/Token;)Lgraphql/language/SourceLocation;",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createSourceLocation",
+            "desc": "(Lgraphql/parser/MultiSourceReader;Lorg/antlr/v4/runtime/tree/TerminalNode;)Lgraphql/language/SourceLocation;",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createPreview",
+            "desc": "(Lgraphql/parser/MultiSourceReader;I)Ljava/lang/String;",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.Parser": {
+        "line": {
+          "covered": 125,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 19,
+          "missed": 9
+        },
+        "method": {
+          "covered": 28,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parse",
+            "desc": "(Lgraphql/parser/ParserEnvironment;)Lgraphql/language/Document;",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parse",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/Document;",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseValue",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/Value;",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseFieldDefinition",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/FieldDefinition;",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseType",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/Type;",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseDocument",
+            "desc": "(Lgraphql/parser/ParserEnvironment;)Lgraphql/language/Document;",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseDocument",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/Document;",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseDocument",
+            "desc": "(Ljava/io/Reader;)Lgraphql/language/Document;",
+            "line": 174,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseDocumentImpl",
+            "desc": "(Lgraphql/parser/ParserEnvironment;)Lgraphql/language/Document;",
+            "line": 181,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseValueImpl",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/Value;",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseTypeImpl",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/Type;",
+            "line": 204,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseFieldDefinitionImpl",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/FieldDefinition;",
+            "line": 219,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseImpl",
+            "desc": "(Lgraphql/parser/ParserEnvironment;Ljava/util/function/BiFunction;)Lgraphql/language/Node;",
+            "line": 235,
+            "counters": {
+              "line": {
+                "covered": 28,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 11,
+                "missed": 7
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setupMultiSourceReader",
+            "desc": "(Lgraphql/parser/ParserEnvironment;Lgraphql/parser/ParserOptions;)Lgraphql/parser/MultiSourceReader;",
+            "line": 290,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setupSafeTokenReader",
+            "desc": "(Lgraphql/parser/ParserEnvironment;Lgraphql/parser/ParserOptions;Lgraphql/parser/MultiSourceReader;)Lgraphql/parser/SafeTokenReader;",
+            "line": 304,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setupCharStream",
+            "desc": "(Lgraphql/parser/SafeTokenReader;)Lorg/antlr/v4/runtime/CodePointCharStream;",
+            "line": 315,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setupGraphqlLexer",
+            "desc": "(Lgraphql/parser/ParserEnvironment;Lgraphql/parser/MultiSourceReader;Lorg/antlr/v4/runtime/CodePointCharStream;)Lgraphql/parser/antlr/GraphqlLexer;",
+            "line": 324,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSafeTokenSource",
+            "desc": "(Lgraphql/parser/ParserEnvironment;Lgraphql/parser/ParserOptions;Lgraphql/parser/MultiSourceReader;Lgraphql/parser/antlr/GraphqlLexer;)Lgraphql/parser/SafeTokenSource;",
+            "line": 349,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setupParserListener",
+            "desc": "(Lgraphql/parser/ParserEnvironment;Lgraphql/parser/MultiSourceReader;Lgraphql/parser/antlr/GraphqlParser;Lgraphql/parser/GraphqlAntlrToLanguage;)V",
+            "line": 361,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "throwIfTokenProblems",
+            "desc": "(Lgraphql/parser/ParserEnvironment;Lorg/antlr/v4/runtime/Token;ILgraphql/parser/MultiSourceReader;Ljava/lang/Class;)V",
+            "line": 427,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAntlrToLanguage",
+            "desc": "(Lorg/antlr/v4/runtime/CommonTokenStream;Lgraphql/parser/MultiSourceReader;Lgraphql/parser/ParserEnvironment;)Lgraphql/parser/GraphqlAntlrToLanguage;",
+            "line": 453,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getSafeTokenSource$0",
+            "desc": "(Lgraphql/parser/ParserEnvironment;Lgraphql/parser/MultiSourceReader;Ljava/lang/Integer;Lorg/antlr/v4/runtime/Token;)V",
+            "line": 351,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$setupSafeTokenReader$0",
+            "desc": "(Lgraphql/parser/ParserEnvironment;ILjava/lang/Integer;)V",
+            "line": 306,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$parseFieldDefinitionImpl$0",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser;Lgraphql/parser/GraphqlAntlrToLanguage;)[Ljava/lang/Object;",
+            "line": 220,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$parseTypeImpl$0",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser;Lgraphql/parser/GraphqlAntlrToLanguage;)[Ljava/lang/Object;",
+            "line": 205,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$parseValueImpl$0",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser;Lgraphql/parser/GraphqlAntlrToLanguage;)[Ljava/lang/Object;",
+            "line": 191,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$parseDocumentImpl$0",
+            "desc": "(Lgraphql/parser/antlr/GraphqlParser;Lgraphql/parser/GraphqlAntlrToLanguage;)[Ljava/lang/Object;",
+            "line": 182,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.parser.ParsingListener": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "lambda$static$0",
+            "desc": "(Lgraphql/parser/ParsingListener$Token;)V",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 14,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.introspection.Introspection": {
+        "line": {
+          "covered": 481,
+          "missed": 9
+        },
+        "branch": {
+          "covered": 101,
+          "missed": 9
+        },
+        "method": {
+          "covered": 44,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "enabledJvmWide",
+            "desc": "(Z)Z",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEnabledJvmWide",
+            "desc": "()Z",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isIntrospectionSensible",
+            "desc": "(Lgraphql/execution/MergedSelectionSet;Lgraphql/execution/ExecutionContext;)Ljava/util/Optional;",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkDisabledError",
+            "desc": "(Lgraphql/execution/MergedField;)Ljava/util/Optional;",
+            "line": 134,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isIntrospectionEnabled",
+            "desc": "(Lgraphql/GraphQLContext;)Z",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "register",
+            "desc": "(Lgraphql/schema/GraphQLFieldsContainer;Ljava/lang/String;Lgraphql/introspection/IntrospectionDataFetcher;)V",
+            "line": 148,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "register",
+            "desc": "(Lgraphql/schema/GraphQLFieldsContainer;Ljava/lang/String;Ljava/lang/Class;Ljava/util/function/Function;)V",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addCodeForIntrospectionTypes",
+            "desc": "(Lgraphql/schema/GraphQLCodeRegistry$Builder;)V",
+            "line": 175,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printDefaultValue",
+            "desc": "(Lgraphql/schema/InputValueWithState;Lgraphql/schema/GraphQLInputType;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/String;",
+            "line": 319,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildSchemaField",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 721,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildTypeField",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 731,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isIntrospectionTypes",
+            "desc": "(Lgraphql/schema/GraphQLNamedType;)Z",
+            "line": 768,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isIntrospectionTypes",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 772,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDef",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLCompositeType;Ljava/lang/String;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 788,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLFieldsContainer;Ljava/lang/String;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 813,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSystemFieldDef",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLCompositeType;Ljava/lang/String;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 825,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$25",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 717,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$24",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 712,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$23",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 685,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$21",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 642,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$22",
+            "desc": "(Ljava/lang/Boolean;Lgraphql/schema/GraphQLArgument;)Z",
+            "line": 645,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$20",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 638,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$19",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 481,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$18",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 473,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$17",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 465,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$15",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 447,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$16",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;)Z",
+            "line": 459,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$13",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 433,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$14",
+            "desc": "(Lgraphql/schema/GraphQLEnumValueDefinition;)Z",
+            "line": 441,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$12",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 422,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$11",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 411,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$9",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 391,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$10",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;)Z",
+            "line": 404,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$7",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 351,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$8",
+            "desc": "(Ljava/lang/Boolean;Lgraphql/schema/GraphQLArgument;)Z",
+            "line": 355,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$6",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 301,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$5",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 292,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$4",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 283,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$3",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 268,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$2",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 237,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$1",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 230,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$static$0",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 208,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 15,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$register$0",
+            "desc": "(Ljava/lang/Class;Ljava/util/function/Function;Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 290,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.introspection.GoodFaithIntrospection": {
+        "line": {
+          "covered": 12,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isEnabledJvmWide",
+            "desc": "()Z",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enabledJvmWide",
+            "desc": "(Z)Z",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEnabled",
+            "desc": "(Lgraphql/GraphQLContext;)Z",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "goodFaithLimits",
+            "desc": "(Lgraphql/validation/QueryComplexityLimits;)Lgraphql/validation/QueryComplexityLimits;",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.introspection.IntrospectionWithDirectivesSupport$1": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/introspection/IntrospectionWithDirectivesSupport;Lgraphql/schema/GraphQLObjectType;Lgraphql/schema/GraphQLObjectType;)V",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "visitGraphQLObjectType",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/util/TraverserContext;)Lgraphql/util/TraversalControl;",
+            "line": 134,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.introspection.IntrospectionWithDirectivesSupport$2": {
+        "line": {
+          "covered": 2,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/introspection/IntrospectionWithDirectivesSupport;Lgraphql/schema/GraphQLDirectiveContainer;ZLjava/lang/String;Lgraphql/schema/GraphQLSchema;)V",
+            "line": 245,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirectiveContainer",
+            "desc": "()Lgraphql/schema/GraphQLDirectiveContainer;",
+            "line": 248,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isDefinedDirective",
+            "desc": "()Z",
+            "line": 253,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDirectiveName",
+            "desc": "()Ljava/lang/String;",
+            "line": 258,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSchema",
+            "desc": "()Lgraphql/schema/GraphQLSchema;",
+            "line": 263,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.introspection.IntrospectionQueryBuilder$Options": {
+        "line": {
+          "covered": 16,
+          "missed": 8
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 8,
+          "missed": 8
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(ZZZZZZI)V",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isDescriptions",
+            "desc": "()Z",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isSpecifiedByUrl",
+            "desc": "()Z",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isOneOf",
+            "desc": "()Z",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isDirectiveIsRepeatable",
+            "desc": "()Z",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isSchemaDescription",
+            "desc": "()Z",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isInputValueDeprecation",
+            "desc": "()Z",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getTypeRefFragmentDepth",
+            "desc": "()I",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "defaultOptions",
+            "desc": "()Lgraphql/introspection/IntrospectionQueryBuilder$Options;",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "descriptions",
+            "desc": "(Z)Lgraphql/introspection/IntrospectionQueryBuilder$Options;",
+            "line": 109,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "specifiedByUrl",
+            "desc": "(Z)Lgraphql/introspection/IntrospectionQueryBuilder$Options;",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isOneOf",
+            "desc": "(Z)Lgraphql/introspection/IntrospectionQueryBuilder$Options;",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "directiveIsRepeatable",
+            "desc": "(Z)Lgraphql/introspection/IntrospectionQueryBuilder$Options;",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "schemaDescription",
+            "desc": "(Z)Lgraphql/introspection/IntrospectionQueryBuilder$Options;",
+            "line": 180,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "inputValueDeprecation",
+            "desc": "(Z)Lgraphql/introspection/IntrospectionQueryBuilder$Options;",
+            "line": 197,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "typeRefFragmentDepth",
+            "desc": "(I)Lgraphql/introspection/IntrospectionQueryBuilder$Options;",
+            "line": 214,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.introspection.IntrospectionWithDirectivesSupport": {
+        "line": {
+          "covered": 75,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 2
+        },
+        "method": {
+          "covered": 28,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/introspection/IntrospectionWithDirectivesSupport$DirectivePredicate;)V",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/introspection/IntrospectionWithDirectivesSupport$DirectivePredicate;Ljava/lang/String;)V",
+            "line": 84,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "apply",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Lgraphql/schema/GraphQLSchema;",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkDirectiveArgumentType",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 148,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkAppliedDirectiveType",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLType;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 161,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addDirectiveDefinitionFilter",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Lgraphql/schema/GraphQLSchema;",
+            "line": 174,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addAppliedDirectives",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/schema/GraphQLCodeRegistry$Builder;Lgraphql/schema/GraphQLObjectType;Lgraphql/schema/GraphQLObjectType;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 184,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filterDirectives",
+            "desc": "(Lgraphql/schema/GraphQLSchema;ZLgraphql/schema/GraphQLDirectiveContainer;Ljava/util/List;)Ljava/util/List;",
+            "line": 228,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filterAppliedDirectives",
+            "desc": "(Lgraphql/schema/GraphQLSchema;ZLgraphql/schema/GraphQLDirectiveContainer;Ljava/util/List;)Ljava/util/List;",
+            "line": 236,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildDirectivePredicateEnv",
+            "desc": "(Lgraphql/schema/GraphQLSchema;ZLgraphql/schema/GraphQLDirectiveContainer;Ljava/lang/String;)Lgraphql/introspection/IntrospectionWithDirectivesSupport$DirectivePredicateEnvironment;",
+            "line": 245,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$filterAppliedDirectives$0",
+            "desc": "(Lgraphql/schema/GraphQLSchema;ZLgraphql/schema/GraphQLDirectiveContainer;Lgraphql/schema/GraphQLAppliedDirective;)Z",
+            "line": 238,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$filterDirectives$0",
+            "desc": "(Lgraphql/schema/GraphQLSchema;ZLgraphql/schema/GraphQLDirectiveContainer;Lgraphql/schema/GraphQLDirective;)Z",
+            "line": 230,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$addAppliedDirectives$6",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 212,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$addAppliedDirectives$5",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 206,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$addAppliedDirectives$3",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 200,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$addAppliedDirectives$4",
+            "desc": "(Lgraphql/schema/GraphQLAppliedDirectiveArgument;)Z",
+            "line": 203,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$addAppliedDirectives$2",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 186,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$addAppliedDirectives$0",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/schema/GraphQLObjectType$Builder;)V",
+            "line": 184,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$addAppliedDirectives$1",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/schema/GraphQLFieldDefinition$Builder;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 184,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$addDirectiveDefinitionFilter$2",
+            "desc": "(Lgraphql/schema/GraphQLCodeRegistry;Lgraphql/schema/GraphQLSchema$Builder;)V",
+            "line": 180,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$addDirectiveDefinitionFilter$1",
+            "desc": "(Lgraphql/schema/DataFetcher;Lgraphql/schema/GraphQLCodeRegistry$Builder;)V",
+            "line": 179,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$addDirectiveDefinitionFilter$0",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/DataFetchingEnvironment;)Ljava/lang/Object;",
+            "line": 175,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$mkAppliedDirectiveType$1",
+            "desc": "(Lgraphql/schema/GraphQLType;Lgraphql/schema/GraphQLFieldDefinition$Builder;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 167,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$mkAppliedDirectiveType$0",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition$Builder;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 164,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$mkDirectiveArgumentType$1",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition$Builder;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 154,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$mkDirectiveArgumentType$0",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition$Builder;)Lgraphql/schema/GraphQLFieldDefinition$Builder;",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$0",
+            "desc": "(Lgraphql/introspection/IntrospectionWithDirectivesSupport$DirectivePredicateEnvironment;)Z",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.introspection.Introspection$DirectiveLocation": {
+        "line": {
+          "covered": 20,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 559,
+            "counters": {
+              "line": {
+                "covered": 20,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.introspection.IntrospectionDisabledError": {
+        "line": {
+          "covered": 4,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 1,
+          "missed": 1
+        },
+        "method": {
+          "covered": 2,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/SourceLocation;)V",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMessage",
+            "desc": "()Ljava/lang/String;",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getLocations",
+            "desc": "()Ljava/util/List;",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/ErrorClassification;",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.introspection.Introspection$TypeKind": {
+        "line": {
+          "covered": 9,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 183,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.introspection.GoodFaithIntrospection$BadFaithIntrospectionError": {
+        "line": {
+          "covered": 6,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "tooManyFields",
+            "desc": "(Ljava/lang/String;)Lgraphql/introspection/GoodFaithIntrospection$BadFaithIntrospectionError;",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "tooBigOperation",
+            "desc": "(Ljava/lang/String;)Lgraphql/introspection/GoodFaithIntrospection$BadFaithIntrospectionError;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMessage",
+            "desc": "()Ljava/lang/String;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/ErrorClassification;",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getLocations",
+            "desc": "()Ljava/util/List;",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.introspection.IntrospectionQuery": {
+        "line": {
+          "covered": 1,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 12,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.introspection.IntrospectionResultToSchema": {
+        "line": {
+          "covered": 176,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 64,
+          "missed": 7
+        },
+        "method": {
+          "covered": 18,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createSchemaDefinition",
+            "desc": "(Lgraphql/ExecutionResult;)Lgraphql/language/Document;",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createSchemaDefinition",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/Document;",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 40,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 24,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createDirective",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/DirectiveDefinition;",
+            "line": 133,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createDirectiveLocations",
+            "desc": "(Ljava/util/List;)Ljava/util/List;",
+            "line": 157,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createTypeDefinition",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/TypeDefinition;",
+            "line": 167,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createScalar",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/TypeDefinition;",
+            "line": 191,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createUnion",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/UnionTypeDefinition;",
+            "line": 204,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createEnum",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/EnumTypeDefinition;",
+            "line": 222,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createInterface",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/InterfaceTypeDefinition;",
+            "line": 244,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createInputObject",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/InputObjectTypeDefinition;",
+            "line": 265,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createObject",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/ObjectTypeDefinition;",
+            "line": 280,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createFields",
+            "desc": "(Ljava/util/List;)Ljava/util/List;",
+            "line": 297,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createDeprecatedDirective",
+            "desc": "(Ljava/util/Map;Lgraphql/language/NodeDirectivesBuilder;)V",
+            "line": 314,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createInputValueDefinitions",
+            "desc": "(Ljava/util/List;)Ljava/util/List;",
+            "line": 327,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createTypeIndirection",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/Type;",
+            "line": 345,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toDescription",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/Description;",
+            "line": 364,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$createDirective$0",
+            "desc": "(Lgraphql/language/DirectiveDefinition$Builder;Ljava/lang/Boolean;)V",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.introspection.IntrospectionQueryBuilder": {
+        "line": {
+          "covered": 134,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 29,
+          "missed": 1
+        },
+        "method": {
+          "covered": 4,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "filter",
+            "desc": "([Ljava/lang/Object;)Ljava/util/List;",
+            "line": 226,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildDocument",
+            "desc": "(Lgraphql/introspection/IntrospectionQueryBuilder$Options;)Lgraphql/language/Document;",
+            "line": 237,
+            "counters": {
+              "line": {
+                "covered": 131,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 29,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "(Lgraphql/introspection/IntrospectionQueryBuilder$Options;)Ljava/lang/String;",
+            "line": 412,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Ljava/lang/String;",
+            "line": 421,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.relay.SimpleListConnection": {
+        "line": {
+          "covered": 58,
+          "missed": 12
+        },
+        "branch": {
+          "covered": 20,
+          "missed": 16
+        },
+        "method": {
+          "covered": 7,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;Ljava/lang/String;)V",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;)V",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildEdges",
+            "desc": "()Ljava/util/List;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "get",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Lgraphql/relay/Connection;",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 27,
+                "missed": 7
+              },
+              "branch": {
+                "covered": 11,
+                "missed": 13
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "emptyConnection",
+            "desc": "()Lgraphql/relay/Connection;",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "cursorForObjectInConnection",
+            "desc": "(Ljava/lang/Object;)Lgraphql/relay/ConnectionCursor;",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 5
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getOffsetFromCursor",
+            "desc": "(Ljava/lang/String;I)I",
+            "line": 135,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createCursor",
+            "desc": "(I)Ljava/lang/String;",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.relay.DefaultEdge": {
+        "line": {
+          "covered": 6,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Object;Lgraphql/relay/ConnectionCursor;)V",
+            "line": 18,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNode",
+            "desc": "()Ljava/lang/Object;",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCursor",
+            "desc": "()Lgraphql/relay/ConnectionCursor;",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.relay.DefaultConnectionCursor": {
+        "line": {
+          "covered": 5,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 1,
+          "missed": 1
+        },
+        "method": {
+          "covered": 2,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getValue",
+            "desc": "()Ljava/lang/String;",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.relay.DefaultPageInfo": {
+        "line": {
+          "covered": 6,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 5
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/relay/ConnectionCursor;Lgraphql/relay/ConnectionCursor;ZZ)V",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getStartCursor",
+            "desc": "()Lgraphql/relay/ConnectionCursor;",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getEndCursor",
+            "desc": "()Lgraphql/relay/ConnectionCursor;",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isHasPreviousPage",
+            "desc": "()Z",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isHasNextPage",
+            "desc": "()Z",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.relay.DefaultConnection": {
+        "line": {
+          "covered": 5,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;Lgraphql/relay/PageInfo;)V",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getEdges",
+            "desc": "()Ljava/util/List;",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPageInfo",
+            "desc": "()Lgraphql/relay/PageInfo;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.relay.InvalidPageSizeException": {
+        "line": {
+          "covered": 0,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 0,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/Throwable;)V",
+            "line": 21,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getLocations",
+            "desc": "()Ljava/util/List;",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/ErrorType;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.relay.Relay$ResolvedGlobalId": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)V",
+            "line": 226,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getType",
+            "desc": "()Ljava/lang/String;",
+            "line": 235,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getId",
+            "desc": "()Ljava/lang/String;",
+            "line": 239,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.relay.Relay": {
+        "line": {
+          "covered": 72,
+          "missed": 76
+        },
+        "branch": {
+          "covered": 1,
+          "missed": 1
+        },
+        "method": {
+          "covered": 8,
+          "missed": 6
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "nodeInterface",
+            "desc": "(Lgraphql/schema/TypeResolver;)Lgraphql/schema/GraphQLInterfaceType;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "nodeField",
+            "desc": "(Lgraphql/schema/GraphQLInterfaceType;Lgraphql/schema/DataFetcher;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getConnectionFieldArguments",
+            "desc": "()Ljava/util/List;",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 22
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getBackwardPaginationConnectionFieldArguments",
+            "desc": "()Ljava/util/List;",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 12
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getForwardPaginationConnectionFieldArguments",
+            "desc": "()Ljava/util/List;",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 12
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "edgeType",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLOutputType;Lgraphql/schema/GraphQLInterfaceType;Ljava/util/List;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 147,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "connectionType",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLObjectType;Ljava/util/List;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mutationWithClientMutationId",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/util/List;Lgraphql/schema/DataFetcher;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 182,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 10
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "addElementToList",
+            "desc": "(Ljava/util/List;Ljava/lang/Object;)Ljava/util/List;",
+            "line": 196,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "mutation",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/util/List;Ljava/util/List;Lgraphql/schema/DataFetcher;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 205,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 16
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toGlobalId",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;",
+            "line": 247,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fromGlobalId",
+            "desc": "(Ljava/lang/String;)Lgraphql/relay/Relay$ResolvedGlobalId;",
+            "line": 251,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 22,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.relay.InvalidCursorException": {
+        "line": {
+          "covered": 4,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/Throwable;)V",
+            "line": 21,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocations",
+            "desc": "()Ljava/util/List;",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/ErrorType;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diff.SchemaDiff$Options": {
+        "line": {
+          "covered": 5,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Z)V",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enforceDirectives",
+            "desc": "()Lgraphql/schema/diff/SchemaDiff$Options;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "defaultOptions",
+            "desc": "()Lgraphql/schema/diff/SchemaDiff$Options;",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diff.DiffLevel": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 8,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diff.DiffEvent": {
+        "line": {
+          "covered": 19,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 11,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/diff/DiffLevel;Lgraphql/schema/diff/DiffCategory;Ljava/lang/String;Ljava/lang/String;Lgraphql/language/TypeKind;Ljava/lang/String;Ljava/util/List;)V",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeName",
+            "desc": "()Ljava/lang/String;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeKind",
+            "desc": "()Lgraphql/language/TypeKind;",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getReasonMsg",
+            "desc": "()Ljava/lang/String;",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLevel",
+            "desc": "()Lgraphql/schema/diff/DiffLevel;",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCategory",
+            "desc": "()Lgraphql/schema/diff/DiffCategory;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getComponents",
+            "desc": "()Ljava/util/List;",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "apiInfo",
+            "desc": "()Lgraphql/schema/diff/DiffEvent$Builder;",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "apiDanger",
+            "desc": "()Lgraphql/schema/diff/DiffEvent$Builder;",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "apiBreakage",
+            "desc": "()Lgraphql/schema/diff/DiffEvent$Builder;",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diff.SchemaDiff$CountingReporter": {
+        "line": {
+          "covered": 10,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/diff/reporting/DifferenceReporter;)V",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "report",
+            "desc": "(Lgraphql/schema/diff/DiffEvent;)V",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "onEnd",
+            "desc": "()V",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diff.DiffCategory": {
+        "line": {
+          "covered": 8,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 8,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diff.DiffSet": {
+        "line": {
+          "covered": 0,
+          "missed": 14
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 0,
+          "missed": 6
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Map;Ljava/util/Map;)V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getOld",
+            "desc": "()Ljava/util/Map;",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getNew",
+            "desc": "()Ljava/util/Map;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "diffSet",
+            "desc": "(Ljava/util/Map;Ljava/util/Map;)Lgraphql/schema/diff/DiffSet;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "diffSet",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLSchema;)Lgraphql/schema/diff/DiffSet;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "introspect",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Ljava/util/Map;",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diff.DiffEvent$Builder": {
+        "line": {
+          "covered": 17,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 9,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "level",
+            "desc": "(Lgraphql/schema/diff/DiffLevel;)Lgraphql/schema/diff/DiffEvent$Builder;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "typeName",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/diff/DiffEvent$Builder;",
+            "line": 106,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldName",
+            "desc": "(Ljava/lang/String;)Lgraphql/schema/diff/DiffEvent$Builder;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "typeKind",
+            "desc": "(Lgraphql/language/TypeKind;)Lgraphql/schema/diff/DiffEvent$Builder;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "category",
+            "desc": "(Lgraphql/schema/diff/DiffCategory;)Lgraphql/schema/diff/DiffEvent$Builder;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "reasonMsg",
+            "desc": "(Ljava/lang/String;[Ljava/lang/Object;)Lgraphql/schema/diff/DiffEvent$Builder;",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "components",
+            "desc": "([Ljava/lang/Object;)Lgraphql/schema/diff/DiffEvent$Builder;",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/schema/diff/DiffEvent;",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diff.SchemaDiffSet": {
+        "line": {
+          "covered": 28,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 12,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Document;Lgraphql/language/Document;Z)V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldSchemaDefinitionDoc",
+            "desc": "()Lgraphql/language/Document;",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewSchemaDefinitionDoc",
+            "desc": "()Lgraphql/language/Document;",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "supportsEnforcingDirectives",
+            "desc": "()Z",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "diffSetFromIntrospection",
+            "desc": "(Ljava/util/Map;Ljava/util/Map;)Lgraphql/schema/diff/SchemaDiffSet;",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "diffSetFromIntrospection",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLSchema;)Lgraphql/schema/diff/SchemaDiffSet;",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "diffSetFromSdl",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;)Lgraphql/schema/diff/SchemaDiffSet;",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "diffSetFromSdl",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLSchema;)Lgraphql/schema/diff/SchemaDiffSet;",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDocumentFromIntrospection",
+            "desc": "(Ljava/util/Map;)Lgraphql/language/Document;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDocumentFromSDLString",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/Document;",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSchemaSdl",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Ljava/lang/String;",
+            "line": 124,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "introspect",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Ljava/util/Map;",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diff.SchemaDiff": {
+        "line": {
+          "covered": 525,
+          "missed": 44
+        },
+        "branch": {
+          "covered": 167,
+          "missed": 13
+        },
+        "method": {
+          "covered": 42,
+          "missed": 6
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/diff/SchemaDiff$Options;)V",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "diffSchema",
+            "desc": "(Lgraphql/schema/diff/DiffSet;Lgraphql/schema/diff/reporting/DifferenceReporter;)I",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 5
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "diffSchema",
+            "desc": "(Lgraphql/schema/diff/SchemaDiffSet;Lgraphql/schema/diff/reporting/DifferenceReporter;)I",
+            "line": 145,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "diffSchemaImpl",
+            "desc": "(Lgraphql/language/Document;Lgraphql/language/Document;Lgraphql/schema/diff/reporting/DifferenceReporter;)V",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkOperation",
+            "desc": "(Lgraphql/schema/diff/DiffCtx;Ljava/lang/String;Ljava/util/Optional;Ljava/util/Optional;)V",
+            "line": 171,
+            "counters": {
+              "line": {
+                "covered": 30,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkType",
+            "desc": "(Lgraphql/schema/diff/DiffCtx;Lgraphql/language/Type;Lgraphql/language/Type;)V",
+            "line": 217,
+            "counters": {
+              "line": {
+                "covered": 41,
+                "missed": 14
+              },
+              "branch": {
+                "covered": 21,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isDeprecated",
+            "desc": "(Lgraphql/language/DirectivesContainer;)Z",
+            "line": 292,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isReservedType",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 296,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isSystemScalar",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 317,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkObjectType",
+            "desc": "(Lgraphql/schema/diff/DiffCtx;Lgraphql/language/ObjectTypeDefinition;Lgraphql/language/ObjectTypeDefinition;)V",
+            "line": 321,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkInterfaceType",
+            "desc": "(Lgraphql/schema/diff/DiffCtx;Lgraphql/language/InterfaceTypeDefinition;Lgraphql/language/InterfaceTypeDefinition;)V",
+            "line": 332,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkUnionType",
+            "desc": "(Lgraphql/schema/diff/DiffCtx;Lgraphql/language/UnionTypeDefinition;Lgraphql/language/UnionTypeDefinition;)V",
+            "line": 341,
+            "counters": {
+              "line": {
+                "covered": 27,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkInputObjectType",
+            "desc": "(Lgraphql/schema/diff/DiffCtx;Lgraphql/language/InputObjectTypeDefinition;Lgraphql/language/InputObjectTypeDefinition;)V",
+            "line": 378,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkInputFields",
+            "desc": "(Lgraphql/schema/diff/DiffCtx;Lgraphql/language/TypeDefinition;Ljava/util/List;Ljava/util/List;)V",
+            "line": 384,
+            "counters": {
+              "line": {
+                "covered": 50,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 12,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkEnumType",
+            "desc": "(Lgraphql/schema/diff/DiffCtx;Lgraphql/language/EnumTypeDefinition;Lgraphql/language/EnumTypeDefinition;)V",
+            "line": 458,
+            "counters": {
+              "line": {
+                "covered": 42,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 14,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkScalarType",
+            "desc": "(Lgraphql/schema/diff/DiffCtx;Lgraphql/language/ScalarTypeDefinition;Lgraphql/language/ScalarTypeDefinition;)V",
+            "line": 511,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkImplements",
+            "desc": "(Lgraphql/schema/diff/DiffCtx;Lgraphql/language/ObjectTypeDefinition;Ljava/util/List;Ljava/util/List;)V",
+            "line": 515,
+            "counters": {
+              "line": {
+                "covered": 28,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 9,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkFields",
+            "desc": "(Lgraphql/schema/diff/DiffCtx;Lgraphql/language/TypeDefinition;Ljava/util/Map;Lgraphql/language/TypeDefinition;Ljava/util/Map;)V",
+            "line": 559,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkFieldRemovals",
+            "desc": "(Lgraphql/schema/diff/DiffCtx;Lgraphql/language/TypeDefinition;Ljava/util/Map;Ljava/util/Map;)V",
+            "line": 569,
+            "counters": {
+              "line": {
+                "covered": 26,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkFieldAdditions",
+            "desc": "(Lgraphql/schema/diff/DiffCtx;Lgraphql/language/TypeDefinition;Ljava/util/Map;Ljava/util/Map;)V",
+            "line": 609,
+            "counters": {
+              "line": {
+                "covered": 27,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkField",
+            "desc": "(Lgraphql/schema/diff/DiffCtx;Lgraphql/language/TypeDefinition;Lgraphql/language/FieldDefinition;Lgraphql/language/FieldDefinition;)V",
+            "line": 642,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkFieldArguments",
+            "desc": "(Lgraphql/schema/diff/DiffCtx;Lgraphql/language/TypeDefinition;Lgraphql/language/FieldDefinition;Ljava/util/List;Ljava/util/List;)V",
+            "line": 667,
+            "counters": {
+              "line": {
+                "covered": 46,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 12,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkFieldArg",
+            "desc": "(Lgraphql/schema/diff/DiffCtx;Lgraphql/language/TypeDefinition;Lgraphql/language/FieldDefinition;Lgraphql/language/InputValueDefinition;Lgraphql/language/InputValueDefinition;)V",
+            "line": 731,
+            "counters": {
+              "line": {
+                "covered": 34,
+                "missed": 9
+              },
+              "branch": {
+                "covered": 18,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkDirectives",
+            "desc": "(Lgraphql/schema/diff/DiffCtx;Lgraphql/language/TypeDefinition;Lgraphql/language/TypeDefinition;)V",
+            "line": 790,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkDirectives",
+            "desc": "(Lgraphql/schema/diff/DiffCtx;Lgraphql/language/TypeDefinition;Ljava/util/List;Ljava/util/List;)V",
+            "line": 797,
+            "counters": {
+              "line": {
+                "covered": 44,
+                "missed": 8
+              },
+              "branch": {
+                "covered": 15,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkTypeWithNonNullAndListOnInputOrArg",
+            "desc": "(Lgraphql/language/Type;Lgraphql/language/Type;)Lgraphql/schema/diff/DiffCategory;",
+            "line": 865,
+            "counters": {
+              "line": {
+                "covered": 21,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 16,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkTypeWithNonNullAndListOnObjectOrInterface",
+            "desc": "(Lgraphql/language/Type;Lgraphql/language/Type;)Lgraphql/schema/diff/DiffCategory;",
+            "line": 909,
+            "counters": {
+              "line": {
+                "covered": 21,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 16,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeName",
+            "desc": "(Lgraphql/language/Type;)Ljava/lang/String;",
+            "line": 954,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSchemaDef",
+            "desc": "(Lgraphql/language/Document;)Ljava/util/Optional;",
+            "line": 962,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOpDef",
+            "desc": "(Ljava/lang/String;Lgraphql/language/SchemaDefinition;)Ljava/util/Optional;",
+            "line": 969,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "synthOperationTypeDefinition",
+            "desc": "(Ljava/util/function/Function;Ljava/lang/String;)Ljava/util/Optional;",
+            "line": 979,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sortedMap",
+            "desc": "(Ljava/util/List;Ljava/util/function/Function;)Ljava/util/Map;",
+            "line": 985,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkDotName",
+            "desc": "([Ljava/lang/String;)Ljava/lang/String;",
+            "line": 991,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$sortedMap$0",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 985,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$synthOperationTypeDefinition$0",
+            "desc": "(Ljava/lang/String;Lgraphql/language/TypeName;Lgraphql/language/ObjectTypeDefinition;)Lgraphql/language/OperationTypeDefinition;",
+            "line": 981,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getOpDef$0",
+            "desc": "(Ljava/lang/String;Lgraphql/language/OperationTypeDefinition;)Z",
+            "line": 971,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$getSchemaDef$0",
+            "desc": "(Lgraphql/language/Definition;)Z",
+            "line": 963,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkImplements$1",
+            "desc": "(Lgraphql/language/Type;)Ljava/lang/String;",
+            "line": 516,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkImplements$0",
+            "desc": "(Lgraphql/language/Type;)Ljava/lang/String;",
+            "line": 515,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkOperation$4",
+            "desc": "(Lgraphql/schema/diff/DiffCtx;Ljava/lang/String;)Ljava/util/Optional;",
+            "line": 178,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkOperation$5",
+            "desc": "(Lgraphql/schema/diff/DiffCtx;Lgraphql/language/Type;)Ljava/util/Optional;",
+            "line": 178,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkOperation$3",
+            "desc": "(Ljava/lang/String;Lgraphql/language/SchemaDefinition;)Ljava/util/Optional;",
+            "line": 177,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$checkOperation$1",
+            "desc": "(Lgraphql/schema/diff/DiffCtx;Ljava/lang/String;)Ljava/util/Optional;",
+            "line": 173,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkOperation$2",
+            "desc": "(Lgraphql/schema/diff/DiffCtx;Lgraphql/language/Type;)Ljava/util/Optional;",
+            "line": 173,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$checkOperation$0",
+            "desc": "(Ljava/lang/String;Lgraphql/language/SchemaDefinition;)Ljava/util/Optional;",
+            "line": 172,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$diffSchema$0",
+            "desc": "()Ljava/lang/String;",
+            "line": 147,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 299,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.schema.diff.DiffCtx": {
+        "line": {
+          "covered": 25,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 9,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/diff/reporting/DifferenceReporter;Lgraphql/language/Document;Lgraphql/language/Document;)V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "report",
+            "desc": "(Lgraphql/schema/diff/DiffEvent;)V",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "examiningType",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "exitType",
+            "desc": "()V",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOldTypeDef",
+            "desc": "(Lgraphql/language/Type;Ljava/lang/Class;)Ljava/util/Optional;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNewTypeDef",
+            "desc": "(Lgraphql/language/Type;Ljava/lang/Class;)Ljava/util/Optional;",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getType",
+            "desc": "(Ljava/lang/String;Ljava/lang/Class;Lgraphql/language/Document;)Ljava/util/Optional;",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getType$1",
+            "desc": "(Ljava/lang/String;Lgraphql/language/TypeDefinition;)Z",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getType$0",
+            "desc": "(Ljava/lang/Class;Lgraphql/language/Definition;)Z",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.tracing.TracingInstrumentation": {
+        "line": {
+          "covered": 20,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 1,
+          "missed": 1
+        },
+        "method": {
+          "covered": 10,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/instrumentation/tracing/TracingInstrumentation$Options;)V",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createStateAsync",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationCreateStateParameters;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "instrumentExecutionResult",
+            "desc": "(Lgraphql/ExecutionResult;Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginFieldFetch",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationFieldFetchParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginParse",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginValidation",
+            "desc": "(Lgraphql/execution/instrumentation/parameters/InstrumentationValidationParameters;Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/instrumentation/InstrumentationContext;",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$beginValidation$0",
+            "desc": "(Lgraphql/execution/instrumentation/tracing/TracingSupport$TracingContext;Ljava/util/List;Ljava/lang/Throwable;)V",
+            "line": 109,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$beginParse$0",
+            "desc": "(Lgraphql/execution/instrumentation/tracing/TracingSupport$TracingContext;Lgraphql/language/Document;Ljava/lang/Throwable;)V",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$beginFieldFetch$0",
+            "desc": "(Lgraphql/execution/instrumentation/tracing/TracingSupport$TracingContext;Ljava/lang/Object;Ljava/lang/Throwable;)V",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.tracing.TracingSupport": {
+        "line": {
+          "covered": 51,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 12,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Z)V",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginField",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;Z)Lgraphql/execution/instrumentation/tracing/TracingSupport$TracingContext;",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginParse",
+            "desc": "()Lgraphql/execution/instrumentation/tracing/TracingSupport$TracingContext;",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "beginValidation",
+            "desc": "()Lgraphql/execution/instrumentation/tracing/TracingSupport$TracingContext;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "traceToMap",
+            "desc": "(Ljava/util/Map;)Lgraphql/execution/instrumentation/tracing/TracingSupport$TracingContext;",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "snapshotTracingData",
+            "desc": "()Ljava/util/Map;",
+            "line": 133,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "copyMap",
+            "desc": "(Ljava/util/Map;)Ljava/lang/Object;",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executionData",
+            "desc": "()Ljava/util/Map;",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "rfc3339",
+            "desc": "(Ljava/time/Instant;)Ljava/lang/String;",
+            "line": 157,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$traceToMap$0",
+            "desc": "(JLjava/util/Map;)V",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$beginField$1",
+            "desc": "(JLgraphql/schema/DataFetchingEnvironment;)V",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$beginField$0",
+            "desc": "()V",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.tracing.TracingInstrumentation$Options": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Z)V",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isIncludeTrivialDataFetchers",
+            "desc": "()Z",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "includeTrivialDataFetchers",
+            "desc": "(Z)Lgraphql/execution/instrumentation/tracing/TracingInstrumentation$Options;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newOptions",
+            "desc": "()Lgraphql/execution/instrumentation/tracing/TracingInstrumentation$Options;",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.ExecutableNormalizedOperationFactory$ExecutableNormalizedOperationFactoryImpl$PossibleMerger": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;Ljava/lang/String;)V",
+            "line": 926,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.ValueToVariableValueCompiler": {
+        "line": {
+          "covered": 63,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 30,
+          "missed": 6
+        },
+        "method": {
+          "covered": 9,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "normalizedInputValueToVariable",
+            "desc": "(Lgraphql/normalized/NormalizedInputValue;I)Lgraphql/normalized/VariableValueWithDefinition;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "normalisedValueToVariableValue",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 18,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 13,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "normalisedValueToVariableValues",
+            "desc": "(Ljava/util/List;)Ljava/util/List;",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "normalisedValueToVariableValues",
+            "desc": "(Ljava/util/Map;)Ljava/util/Map;",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toVariableValue",
+            "desc": "(Lgraphql/language/ObjectValue;)Ljava/util/Map;",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toVariableValues",
+            "desc": "(Ljava/util/List;)Ljava/util/List;",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toVariableValue",
+            "desc": "(Lgraphql/language/Value;)Ljava/lang/Object;",
+            "line": 110,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 15,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "maybeClass",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getVarName",
+            "desc": "(I)Ljava/lang/String;",
+            "line": 135,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$normalisedValueToVariableValues$0",
+            "desc": "(Ljava/util/Map;Ljava/lang/String;Ljava/lang/Object;)V",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.ArgumentMaker": {
+        "line": {
+          "covered": 45,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 16,
+          "missed": 2
+        },
+        "method": {
+          "covered": 5,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "createArguments",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;Lgraphql/normalized/VariableAccumulator;)Ljava/util/List;",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createDirectiveArguments",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;Lgraphql/execution/directives/QueryDirectives;Lgraphql/execution/directives/QueryAppliedDirective;Lgraphql/normalized/VariableAccumulator;)Ljava/util/List;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "argValue",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;Lgraphql/execution/directives/QueryAppliedDirective;Ljava/lang/String;Ljava/lang/Object;Lgraphql/normalized/VariableAccumulator;)Lgraphql/language/Value;",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "argValue",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;Lgraphql/execution/directives/QueryAppliedDirective;Ljava/lang/String;Lgraphql/normalized/NormalizedInputValue;Lgraphql/normalized/VariableAccumulator;)Lgraphql/language/Value;",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$argValue$0",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;Lgraphql/execution/directives/QueryAppliedDirective;Ljava/lang/String;Lgraphql/normalized/VariableAccumulator;Ljava/lang/Object;)Lgraphql/language/Value;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.ENFMerger": {
+        "line": {
+          "covered": 104,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 71,
+          "missed": 5
+        },
+        "method": {
+          "covered": 11,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "merge",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;Ljava/util/List;Lgraphql/schema/GraphQLSchema;Z)V",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 43,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 26,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isFieldInSharedInterface",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;Lgraphql/normalized/ExecutableNormalizedField;Lgraphql/schema/GraphQLSchema;)Z",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "areFieldSetsTheSame",
+            "desc": "(Ljava/util/List;)Z",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 12,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "compareTwoFieldSets",
+            "desc": "(Ljava/util/Set;Ljava/util/Set;)Z",
+            "line": 134,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isContained",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;Ljava/util/Set;)Z",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "compareWithoutChildren",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;Lgraphql/normalized/ExecutableNormalizedField;)Z",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sameArguments",
+            "desc": "(Ljava/util/List;Ljava/util/List;)Z",
+            "line": 173,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "findArgumentByName",
+            "desc": "(Ljava/lang/String;Ljava/util/List;)Lgraphql/language/Argument;",
+            "line": 189,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isFieldInSharedInterface$1",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLInterfaceType;)Z",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isFieldInSharedInterface$0",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLInterfaceType;)Z",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$merge$0",
+            "desc": "(Ljava/util/Set;Lgraphql/normalized/ExecutableNormalizedField;)V",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.ExecutableNormalizedOperationFactory": {
+        "line": {
+          "covered": 21,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "createExecutableNormalizedOperation",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/Document;Ljava/lang/String;Lgraphql/execution/CoercedVariables;)Lgraphql/normalized/ExecutableNormalizedOperation;",
+            "line": 263,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createExecutableNormalizedOperation",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/Document;Ljava/lang/String;Lgraphql/execution/CoercedVariables;Lgraphql/normalized/ExecutableNormalizedOperationFactory$Options;)Lgraphql/normalized/ExecutableNormalizedOperation;",
+            "line": 290,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createExecutableNormalizedOperation",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/OperationDefinition;Ljava/util/Map;Lgraphql/execution/CoercedVariables;)Lgraphql/normalized/ExecutableNormalizedOperation;",
+            "line": 317,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "createExecutableNormalizedOperation",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/OperationDefinition;Ljava/util/Map;Lgraphql/execution/CoercedVariables;Lgraphql/normalized/ExecutableNormalizedOperationFactory$Options;)Lgraphql/normalized/ExecutableNormalizedOperation;",
+            "line": 341,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createExecutableNormalizedOperationWithRawVariables",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/Document;Ljava/lang/String;Lgraphql/execution/RawVariables;)Lgraphql/normalized/ExecutableNormalizedOperation;",
+            "line": 366,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createExecutableNormalizedOperationWithRawVariables",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/Document;Ljava/lang/String;Lgraphql/execution/RawVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)Lgraphql/normalized/ExecutableNormalizedOperation;",
+            "line": 395,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "createExecutableNormalizedOperationWithRawVariables",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/Document;Ljava/lang/String;Lgraphql/execution/RawVariables;Lgraphql/normalized/ExecutableNormalizedOperationFactory$Options;)Lgraphql/normalized/ExecutableNormalizedOperation;",
+            "line": 421,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 240,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.ExecutableNormalizedOperation": {
+        "line": {
+          "covered": 29,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 3
+        },
+        "method": {
+          "covered": 13,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/OperationDefinition$Operation;Ljava/lang/String;Ljava/util/Map;Ljava/util/List;Lcom/google/common/collect/ImmutableListMultimap;Ljava/util/Map;Ljava/util/Map;Lcom/google/common/collect/ImmutableListMultimap;II)V",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOperation",
+            "desc": "()Lgraphql/language/OperationDefinition$Operation;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOperationName",
+            "desc": "()Ljava/lang/String;",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOperationDirectives",
+            "desc": "()Ljava/util/Map;",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOperationFieldCount",
+            "desc": "()I",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOperationDepth",
+            "desc": "()I",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCoordinatesToNormalizedFields",
+            "desc": "()Lcom/google/common/collect/ImmutableListMultimap;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTopLevelFields",
+            "desc": "()Ljava/util/List;",
+            "line": 118,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldToNormalizedField",
+            "desc": "()Lcom/google/common/collect/ImmutableListMultimap;",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNormalizedFields",
+            "desc": "(Lgraphql/language/Field;)Ljava/util/List;",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getNormalizedFieldToMergedField",
+            "desc": "()Ljava/util/Map;",
+            "line": 145,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMergedField",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;)Lgraphql/execution/MergedField;",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getNormalizedFieldToQueryDirectives",
+            "desc": "()Ljava/util/Map;",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getQueryDirectives",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;)Lgraphql/execution/directives/QueryDirectives;",
+            "line": 175,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNormalizedField",
+            "desc": "(Lgraphql/execution/MergedField;Lgraphql/schema/GraphQLFieldsContainer;Lgraphql/execution/ResultPath;)Lgraphql/normalized/ExecutableNormalizedField;",
+            "line": 188,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.ExecutableNormalizedOperationToAstCompiler$ExecutionFragmentDetails": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/normalized/incremental/NormalizedDeferredExecution;)V",
+            "line": 451,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.ExecutableNormalizedOperationToAstCompiler$CompilerResult": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Document;Ljava/util/Map;)V",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDocument",
+            "desc": "()Lgraphql/language/Document;",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getVariables",
+            "desc": "()Ljava/util/Map;",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.ExecutableNormalizedField$Builder": {
+        "line": {
+          "covered": 25,
+          "missed": 19
+        },
+        "branch": {
+          "covered": 3,
+          "missed": 1
+        },
+        "method": {
+          "covered": 10,
+          "missed": 4
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 610,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;)V",
+            "line": 610,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 18
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "clearObjectTypesNames",
+            "desc": "()Lgraphql/normalized/ExecutableNormalizedField$Builder;",
+            "line": 639,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "objectTypeNames",
+            "desc": "(Ljava/util/List;)Lgraphql/normalized/ExecutableNormalizedField$Builder;",
+            "line": 644,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "alias",
+            "desc": "(Ljava/lang/String;)Lgraphql/normalized/ExecutableNormalizedField$Builder;",
+            "line": 649,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "normalizedArguments",
+            "desc": "(Ljava/util/Map;)Lgraphql/normalized/ExecutableNormalizedField$Builder;",
+            "line": 654,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "resolvedArguments",
+            "desc": "(Ljava/util/Map;)Lgraphql/normalized/ExecutableNormalizedField$Builder;",
+            "line": 659,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "astArguments",
+            "desc": "(Ljava/util/List;)Lgraphql/normalized/ExecutableNormalizedField$Builder;",
+            "line": 664,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldName",
+            "desc": "(Ljava/lang/String;)Lgraphql/normalized/ExecutableNormalizedField$Builder;",
+            "line": 670,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "children",
+            "desc": "(Ljava/util/List;)Lgraphql/normalized/ExecutableNormalizedField$Builder;",
+            "line": 676,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "level",
+            "desc": "(I)Lgraphql/normalized/ExecutableNormalizedField$Builder;",
+            "line": 682,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parent",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;)Lgraphql/normalized/ExecutableNormalizedField$Builder;",
+            "line": 687,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deferredExecutions",
+            "desc": "(Ljava/util/LinkedHashSet;)Lgraphql/normalized/ExecutableNormalizedField$Builder;",
+            "line": 692,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/normalized/ExecutableNormalizedField;",
+            "line": 697,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.ExecutableNormalizedOperationToAstCompiler": {
+        "line": {
+          "covered": 121,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 34,
+          "missed": 4
+        },
+        "method": {
+          "covered": 27,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "compileToDocument",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/OperationDefinition$Operation;Ljava/lang/String;Ljava/util/List;Lgraphql/normalized/VariablePredicate;)Lgraphql/normalized/ExecutableNormalizedOperationToAstCompiler$CompilerResult;",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "compileToDocument",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/OperationDefinition$Operation;Ljava/lang/String;Ljava/util/List;Ljava/util/Map;Lgraphql/normalized/VariablePredicate;)Lgraphql/normalized/ExecutableNormalizedOperationToAstCompiler$CompilerResult;",
+            "line": 128,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "compileToDocumentWithDeferSupport",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/OperationDefinition$Operation;Ljava/lang/String;Ljava/util/List;Lgraphql/normalized/VariablePredicate;)Lgraphql/normalized/ExecutableNormalizedOperationToAstCompiler$CompilerResult;",
+            "line": 155,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "compileToDocumentWithDeferSupport",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/OperationDefinition$Operation;Ljava/lang/String;Ljava/util/List;Ljava/util/Map;Lgraphql/normalized/VariablePredicate;)Lgraphql/normalized/ExecutableNormalizedOperationToAstCompiler$CompilerResult;",
+            "line": 183,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "compileToDocument",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/OperationDefinition$Operation;Ljava/lang/String;Ljava/util/List;Ljava/util/Map;Lgraphql/normalized/VariablePredicate;Z)Lgraphql/normalized/ExecutableNormalizedOperationToAstCompiler$CompilerResult;",
+            "line": 193,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "subselectionsForNormalizedField",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Ljava/lang/String;Ljava/util/List;Ljava/util/Map;Lgraphql/normalized/VariableAccumulator;Z)Ljava/util/List;",
+            "line": 220,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "subselectionsForNormalizedFieldNoDeferSupport",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Ljava/lang/String;Ljava/util/List;Ljava/util/Map;Lgraphql/normalized/VariableAccumulator;)Ljava/util/List;",
+            "line": 232,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "subselectionsForNormalizedFieldWithDeferSupport",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Ljava/lang/String;Ljava/util/List;Ljava/util/Map;Lgraphql/normalized/VariableAccumulator;)Ljava/util/List;",
+            "line": 268,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "selectionForNormalizedField",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/normalized/ExecutableNormalizedField;Ljava/util/Map;Lgraphql/normalized/VariableAccumulator;Z)Ljava/util/Map;",
+            "line": 341,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "selectionForNormalizedField",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Ljava/lang/String;Lgraphql/normalized/ExecutableNormalizedField;Ljava/util/Map;Lgraphql/normalized/VariableAccumulator;Z)Lgraphql/language/Field;",
+            "line": 360,
+            "counters": {
+              "line": {
+                "covered": 19,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildDirectives",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;Lgraphql/execution/directives/QueryDirectives;Lgraphql/normalized/VariableAccumulator;)Ljava/util/List;",
+            "line": 394,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildDirective",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;Lgraphql/execution/directives/QueryDirectives;Lgraphql/execution/directives/QueryAppliedDirective;Lgraphql/normalized/VariableAccumulator;)Lgraphql/language/Directive;",
+            "line": 405,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "selectionSetOrNullIfEmpty",
+            "desc": "(Ljava/util/List;)Lgraphql/language/SelectionSet;",
+            "line": 413,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "selectionSet",
+            "desc": "(Ljava/util/List;)Lgraphql/language/SelectionSet;",
+            "line": 417,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Ljava/lang/String;Lgraphql/normalized/ExecutableNormalizedField;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 425,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOperationType",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/OperationDefinition$Operation;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 432,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildDirectives$1",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;Lgraphql/execution/directives/QueryDirectives;Lgraphql/normalized/VariableAccumulator;Lgraphql/execution/directives/QueryAppliedDirective;)Lgraphql/language/Directive;",
+            "line": 399,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildDirectives$0",
+            "desc": "(Ljava/util/Map$Entry;)Ljava/util/stream/Stream;",
+            "line": 398,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$subselectionsForNormalizedFieldWithDeferSupport$6",
+            "desc": "(Lcom/google/common/collect/ImmutableList$Builder;Lgraphql/normalized/ExecutableNormalizedOperationToAstCompiler$ExecutionFragmentDetails;Ljava/util/List;)V",
+            "line": 308,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$subselectionsForNormalizedFieldWithDeferSupport$4",
+            "desc": "(Ljava/util/Map;Lgraphql/language/Field;Lgraphql/normalized/incremental/NormalizedDeferredExecution;)V",
+            "line": 298,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$subselectionsForNormalizedFieldWithDeferSupport$5",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedOperationToAstCompiler$ExecutionFragmentDetails;)Ljava/util/List;",
+            "line": 299,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$subselectionsForNormalizedFieldWithDeferSupport$0",
+            "desc": "(Ljava/util/LinkedHashSet;Ljava/util/Map;Ljava/lang/String;Lgraphql/language/Field;)V",
+            "line": 281,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$subselectionsForNormalizedFieldWithDeferSupport$2",
+            "desc": "(Ljava/util/Map;Ljava/lang/String;Lgraphql/language/Field;Lgraphql/normalized/incremental/NormalizedDeferredExecution;)V",
+            "line": 287,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$subselectionsForNormalizedFieldWithDeferSupport$3",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedOperationToAstCompiler$ExecutionFragmentDetails;)Ljava/util/List;",
+            "line": 288,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$subselectionsForNormalizedFieldWithDeferSupport$1",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedOperationToAstCompiler$ExecutionFragmentDetails;)Ljava/util/List;",
+            "line": 283,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$subselectionsForNormalizedFieldNoDeferSupport$2",
+            "desc": "(Lcom/google/common/collect/ImmutableList$Builder;Ljava/lang/String;Ljava/util/List;)V",
+            "line": 251,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$subselectionsForNormalizedFieldNoDeferSupport$0",
+            "desc": "(Ljava/util/Map;Ljava/lang/String;Lgraphql/language/Field;)V",
+            "line": 243,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$subselectionsForNormalizedFieldNoDeferSupport$1",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 243,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.ExecutableNormalizedOperationFactory$ExecutableNormalizedOperationFactoryImpl$CollectedFieldGroup": {
+        "line": {
+          "covered": 5,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Set;Ljava/util/Set;Ljava/util/Set;)V",
+            "line": 951,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.ExecutableNormalizedOperationFactory$ExecutableNormalizedOperationFactoryImpl$CollectedField": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Field;Ljava/util/Set;Lgraphql/schema/GraphQLCompositeType;Lgraphql/normalized/incremental/NormalizedDeferredExecution;)V",
+            "line": 938,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.VariablePredicate": {
+        "line": {
+          "covered": 0,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 0,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "shouldMakeVariable",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;Lgraphql/execution/directives/QueryAppliedDirective;Ljava/lang/String;Lgraphql/normalized/NormalizedInputValue;)Z",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.VariableValueWithDefinition": {
+        "line": {
+          "covered": 8,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Object;Lgraphql/language/VariableDefinition;Lgraphql/language/VariableReference;)V",
+            "line": 13,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getValue",
+            "desc": "()Ljava/lang/Object;",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefinition",
+            "desc": "()Lgraphql/language/VariableDefinition;",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getVariableReference",
+            "desc": "()Lgraphql/language/VariableReference;",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.ExecutableNormalizedOperationFactory$ExecutableNormalizedOperationFactoryImpl": {
+        "line": {
+          "covered": 248,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 86,
+          "missed": 8
+        },
+        "method": {
+          "covered": 34,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/OperationDefinition;Ljava/util/Map;Lgraphql/execution/CoercedVariables;Lgraphql/execution/NormalizedVariables;Lgraphql/normalized/ExecutableNormalizedOperationFactory$Options;)V",
+            "line": 454,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createNormalizedQueryImpl",
+            "desc": "()Lgraphql/normalized/ExecutableNormalizedOperation;",
+            "line": 487,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "captureMergedField",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;Lgraphql/execution/MergedField;)V",
+            "line": 516,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildEnfsRecursively",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;Lcom/google/common/collect/ImmutableList;I)V",
+            "line": 529,
+            "counters": {
+              "line": {
+                "covered": 38,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 13,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkMaxDepthExceeded",
+            "desc": "(I)V",
+            "line": 599,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newMergedField",
+            "desc": "(Lcom/google/common/collect/ImmutableList;)Lgraphql/execution/MergedField;",
+            "line": 605,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "updateFieldToNFMap",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;Lcom/google/common/collect/ImmutableList;)V",
+            "line": 610,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "updateCoordinatedToNFMap",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;)V",
+            "line": 616,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldsByResultKey",
+            "desc": "(Ljava/util/List;)Ljava/util/Map;",
+            "line": 624,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createNFs",
+            "desc": "(Lcom/google/common/collect/ImmutableList$Builder;Ljava/util/Map;Lcom/google/common/collect/ImmutableListMultimap$Builder;ILgraphql/normalized/ExecutableNormalizedField;)V",
+            "line": 637,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 11,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createNF",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedOperationFactory$ExecutableNormalizedOperationFactoryImpl$CollectedFieldGroup;ILgraphql/normalized/ExecutableNormalizedField;)Lgraphql/normalized/ExecutableNormalizedField;",
+            "line": 665,
+            "counters": {
+              "line": {
+                "covered": 22,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "groupByCommonParents",
+            "desc": "(Ljava/util/Collection;)Ljava/util/List;",
+            "line": 694,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "groupByCommonParentsNoDeferSupport",
+            "desc": "(Ljava/util/Collection;)Ljava/util/List;",
+            "line": 702,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "groupByCommonParentsWithDeferSupport",
+            "desc": "(Ljava/util/Collection;)Ljava/util/List;",
+            "line": 720,
+            "counters": {
+              "line": {
+                "covered": 24,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 9,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "filterExecutionsFromType",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;)Ljava/util/function/Predicate;",
+            "line": 762,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "listDuplicatedLabels",
+            "desc": "(Ljava/util/Collection;)Ljava/util/Set;",
+            "line": 770,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "collectFromSelectionSet",
+            "desc": "(Lgraphql/language/SelectionSet;Ljava/util/List;Lgraphql/schema/GraphQLCompositeType;Ljava/util/Set;Lgraphql/normalized/incremental/NormalizedDeferredExecution;)V",
+            "line": 787,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "collectFragmentSpread",
+            "desc": "(Ljava/util/List;Lgraphql/language/FragmentSpread;Ljava/util/Set;)V",
+            "line": 802,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "collectInlineFragment",
+            "desc": "(Ljava/util/List;Lgraphql/language/InlineFragment;Ljava/util/Set;Lgraphql/schema/GraphQLCompositeType;)V",
+            "line": 831,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildDeferredExecution",
+            "desc": "(Ljava/util/List;Ljava/util/Set;)Lgraphql/normalized/incremental/NormalizedDeferredExecution;",
+            "line": 854,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "collectField",
+            "desc": "(Ljava/util/List;Lgraphql/language/Field;Ljava/util/Set;Lgraphql/schema/GraphQLCompositeType;Lgraphql/normalized/incremental/NormalizedDeferredExecution;)V",
+            "line": 871,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "narrowDownPossibleObjects",
+            "desc": "(Ljava/util/Set;Lgraphql/schema/GraphQLCompositeType;)Ljava/util/Set;",
+            "line": 887,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "resolvePossibleObjects",
+            "desc": "(Ljava/util/List;)Lcom/google/common/collect/ImmutableSet;",
+            "line": 897,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "resolvePossibleObjects",
+            "desc": "(Lgraphql/schema/GraphQLCompositeType;)Lcom/google/common/collect/ImmutableSet;",
+            "line": 910,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildDeferredExecution$0",
+            "desc": "(Ljava/util/Set;Ljava/lang/String;)Lgraphql/normalized/incremental/NormalizedDeferredExecution;",
+            "line": 861,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$listDuplicatedLabels$0",
+            "desc": "(Ljava/util/Map$Entry;)Z",
+            "line": 776,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$filterExecutionsFromType$0",
+            "desc": "(Ljava/lang/String;Lgraphql/normalized/incremental/NormalizedDeferredExecution;)Z",
+            "line": 763,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$groupByCommonParentsWithDeferSupport$1",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/normalized/ExecutableNormalizedOperationFactory$ExecutableNormalizedOperationFactoryImpl$CollectedField;)Z",
+            "line": 750,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$groupByCommonParentsWithDeferSupport$0",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedOperationFactory$ExecutableNormalizedOperationFactoryImpl$CollectedField;)Lgraphql/schema/GraphQLType;",
+            "line": 743,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$groupByCommonParentsNoDeferSupport$1",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;Lgraphql/normalized/ExecutableNormalizedOperationFactory$ExecutableNormalizedOperationFactoryImpl$CollectedField;)Z",
+            "line": 713,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$groupByCommonParentsNoDeferSupport$0",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedOperationFactory$ExecutableNormalizedOperationFactoryImpl$CollectedField;)Lgraphql/schema/GraphQLType;",
+            "line": 707,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$fieldsByResultKey$0",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 626,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$newMergedField$0",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedOperationFactory$ExecutableNormalizedOperationFactoryImpl$CollectedField;)Lgraphql/language/Field;",
+            "line": 605,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$captureMergedField$0",
+            "desc": "()Lgraphql/execution/NormalizedVariables;",
+            "line": 519,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.ExecutableNormalizedField": {
+        "line": {
+          "covered": 134,
+          "missed": 36
+        },
+        "branch": {
+          "covered": 62,
+          "missed": 8
+        },
+        "method": {
+          "covered": 36,
+          "missed": 14
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField$Builder;)V",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isConditional",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Z",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 21,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 23,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasChildren",
+            "desc": "()Z",
+            "line": 180,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getType",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Lgraphql/schema/GraphQLOutputType;",
+            "line": 184,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypes",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Ljava/util/List;",
+            "line": 191,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "forEachFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Ljava/util/function/Consumer;)V",
+            "line": 195,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinitions",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Ljava/util/List;",
+            "line": 212,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOneFieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 223,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "resolveIntrospectionField",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Ljava/util/Set;Ljava/lang/String;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 235,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addObjectTypeNames",
+            "desc": "(Ljava/util/Collection;)V",
+            "line": 249,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "setObjectTypeNames",
+            "desc": "(Ljava/util/Collection;)V",
+            "line": 254,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addChild",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;)V",
+            "line": 260,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clearChildren",
+            "desc": "()V",
+            "line": 265,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "setDeferredExecutions",
+            "desc": "(Ljava/util/Collection;)V",
+            "line": 270,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "addDeferredExecutions",
+            "desc": "(Ljava/util/Collection;)V",
+            "line": 275,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 289,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldName",
+            "desc": "()Ljava/lang/String;",
+            "line": 299,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getResultKey",
+            "desc": "()Ljava/lang/String;",
+            "line": 311,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAlias",
+            "desc": "()Ljava/lang/String;",
+            "line": 324,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAstArguments",
+            "desc": "()Lcom/google/common/collect/ImmutableList;",
+            "line": 331,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNormalizedArgument",
+            "desc": "(Ljava/lang/String;)Lgraphql/normalized/NormalizedInputValue;",
+            "line": 342,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNormalizedArguments",
+            "desc": "()Lcom/google/common/collect/ImmutableMap;",
+            "line": 349,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getResolvedArguments",
+            "desc": "()Ljava/util/LinkedHashMap;",
+            "line": 356,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getObjectTypeNames",
+            "desc": "()Ljava/util/Set;",
+            "line": 373,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSingleObjectTypeName",
+            "desc": "()Ljava/lang/String;",
+            "line": 384,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "printDetails",
+            "desc": "()Ljava/lang/String;",
+            "line": 391,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "objectTypeNamesToString",
+            "desc": "()Ljava/lang/String;",
+            "line": 402,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getListOfResultKeys",
+            "desc": "()Ljava/util/List;",
+            "line": 416,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "()Ljava/util/List;",
+            "line": 429,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildrenWithSameResultKey",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 440,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "(I)Ljava/util/List;",
+            "line": 444,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getChildren",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 461,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLevel",
+            "desc": "()I",
+            "line": 473,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParent",
+            "desc": "()Lgraphql/normalized/ExecutableNormalizedField;",
+            "line": 480,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDeferredExecutions",
+            "desc": "()Ljava/util/LinkedHashSet;",
+            "line": 490,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceParent",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;)V",
+            "line": 495,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 501,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "traverseSubTree",
+            "desc": "(Ljava/util/function/Consumer;)V",
+            "line": 516,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "traverseImpl",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;Ljava/util/function/Consumer;II)V",
+            "line": 525,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 5
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getInterfacesCommonToAllOutputTypes",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Ljava/util/Set;",
+            "line": 543,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newNormalizedField",
+            "desc": "()Lgraphql/normalized/ExecutableNormalizedField$Builder;",
+            "line": 593,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/normalized/ExecutableNormalizedField;",
+            "line": 604,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$getInterfacesCommonToAllOutputTypes$0",
+            "desc": "(Lgraphql/util/MutableRef;Lgraphql/schema/GraphQLFieldDefinition;)V",
+            "line": 560,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$traverseImpl$0",
+            "desc": "(Ljava/util/function/Consumer;IILgraphql/normalized/ExecutableNormalizedField;)V",
+            "line": 530,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$traverseSubTree$0",
+            "desc": "(Ljava/util/function/Consumer;Lgraphql/normalized/ExecutableNormalizedField;)V",
+            "line": 517,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$getChildren$1",
+            "desc": "(Ljava/lang/String;Lgraphql/normalized/ExecutableNormalizedField;)Z",
+            "line": 462,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getChildren$0",
+            "desc": "(Ljava/util/List;ILgraphql/normalized/ExecutableNormalizedField;)V",
+            "line": 448,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$getChildrenWithSameResultKey$0",
+            "desc": "(Ljava/lang/String;Lgraphql/normalized/ExecutableNormalizedField;)Z",
+            "line": 440,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getTypes$0",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;)Lgraphql/schema/GraphQLOutputType;",
+            "line": 191,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$getType$0",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;)Ljava/lang/String;",
+            "line": 185,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.VariableAccumulator": {
+        "line": {
+          "covered": 18,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 8,
+          "missed": 2
+        },
+        "method": {
+          "covered": 7,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/normalized/VariablePredicate;)V",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "shouldMakeVariable",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedField;Lgraphql/execution/directives/QueryAppliedDirective;Ljava/lang/String;Lgraphql/normalized/NormalizedInputValue;)Z",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "accumulateVariable",
+            "desc": "(Lgraphql/normalized/NormalizedInputValue;)Lgraphql/normalized/VariableValueWithDefinition;",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAccumulatedSize",
+            "desc": "()I",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getVariableDefinitions",
+            "desc": "()Ljava/util/List;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getVariablesMap",
+            "desc": "()Ljava/util/Map;",
+            "line": 63,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getVariablesMap$0",
+            "desc": "(Ljava/util/Map;Lgraphql/normalized/VariableValueWithDefinition;)V",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.NormalizedInputValue": {
+        "line": {
+          "covered": 29,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 19,
+          "missed": 1
+        },
+        "method": {
+          "covered": 13,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/Object;)V",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertValidTypeName",
+            "desc": "(Ljava/lang/String;)Ljava/lang/String;",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unwrapAll",
+            "desc": "(Ljava/lang/String;)Ljava/lang/String;",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeName",
+            "desc": "()Ljava/lang/String;",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getUnwrappedTypeName",
+            "desc": "()Ljava/lang/String;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getValue",
+            "desc": "()Ljava/lang/Object;",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isListLike",
+            "desc": "()Z",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isNonNullable",
+            "desc": "()Z",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isNullable",
+            "desc": "()Z",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isWrapped",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isListOnly",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unwrapOne",
+            "desc": "(Ljava/lang/String;)Ljava/lang/String;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.normalized.ExecutableNormalizedOperationFactory$Options": {
+        "line": {
+          "covered": 21,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 13,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/GraphQLContext;Ljava/util/Locale;IIZ)V",
+            "line": 109,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setDefaultOptions",
+            "desc": "(Lgraphql/normalized/ExecutableNormalizedOperationFactory$Options;)V",
+            "line": 123,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "defaultOptions",
+            "desc": "()Lgraphql/normalized/ExecutableNormalizedOperationFactory$Options;",
+            "line": 133,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "locale",
+            "desc": "(Ljava/util/Locale;)Lgraphql/normalized/ExecutableNormalizedOperationFactory$Options;",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "graphQLContext",
+            "desc": "(Lgraphql/GraphQLContext;)Lgraphql/normalized/ExecutableNormalizedOperationFactory$Options;",
+            "line": 159,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "maxChildrenDepth",
+            "desc": "(I)Lgraphql/normalized/ExecutableNormalizedOperationFactory$Options;",
+            "line": 171,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "maxFieldsCount",
+            "desc": "(I)Lgraphql/normalized/ExecutableNormalizedOperationFactory$Options;",
+            "line": 183,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deferSupport",
+            "desc": "(Z)Lgraphql/normalized/ExecutableNormalizedOperationFactory$Options;",
+            "line": 195,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getGraphQLContext",
+            "desc": "()Lgraphql/GraphQLContext;",
+            "line": 204,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocale",
+            "desc": "()Ljava/util/Locale;",
+            "line": 213,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMaxChildrenDepth",
+            "desc": "()I",
+            "line": 222,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMaxFieldsCount",
+            "desc": "()I",
+            "line": 226,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDeferSupport",
+            "desc": "()Z",
+            "line": 236,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.directives.QueryAppliedDirectiveArgument": {
+        "line": {
+          "covered": 12,
+          "missed": 9
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 6
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/InputValueWithState;Lgraphql/schema/GraphQLInputType;Lgraphql/language/Argument;)V",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getType",
+            "desc": "()Lgraphql/schema/GraphQLInputType;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasSetValue",
+            "desc": "()Z",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getArgumentValue",
+            "desc": "()Lgraphql/schema/InputValueWithState;",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getValue",
+            "desc": "()Ljava/lang/Object;",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDescription",
+            "desc": "()Ljava/lang/String;",
+            "line": 97,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDefinition",
+            "desc": "()Lgraphql/language/Argument;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/execution/directives/QueryAppliedDirectiveArgument;",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "newArgument",
+            "desc": "()Lgraphql/execution/directives/QueryAppliedDirectiveArgument$Builder;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newArgument",
+            "desc": "(Lgraphql/execution/directives/QueryAppliedDirectiveArgument;)Lgraphql/execution/directives/QueryAppliedDirectiveArgument$Builder;",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.directives.QueryAppliedDirective": {
+        "line": {
+          "covered": 13,
+          "missed": 13
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 2
+        },
+        "method": {
+          "covered": 5,
+          "missed": 5
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/Directive;Ljava/util/Collection;)V",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDescription",
+            "desc": "()Ljava/lang/String;",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getArguments",
+            "desc": "()Ljava/util/List;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgument",
+            "desc": "(Ljava/lang/String;)Lgraphql/execution/directives/QueryAppliedDirectiveArgument;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefinition",
+            "desc": "()Lgraphql/language/Directive;",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 5
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/execution/directives/QueryAppliedDirective;",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "newDirective",
+            "desc": "()Lgraphql/execution/directives/QueryAppliedDirective$Builder;",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newDirective",
+            "desc": "(Lgraphql/execution/directives/QueryAppliedDirective;)Lgraphql/execution/directives/QueryAppliedDirective$Builder;",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.directives.QueryDirectivesImpl": {
+        "line": {
+          "covered": 71,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 6,
+          "missed": 2
+        },
+        "method": {
+          "covered": 15,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/MergedField;Lgraphql/schema/GraphQLSchema;Lgraphql/execution/CoercedVariables;Ljava/util/function/Supplier;Lgraphql/GraphQLContext;Ljava/util/Locale;)V",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "computeValuesLazily",
+            "desc": "()V",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getImmediateDirectivesByField",
+            "desc": "()Ljava/util/Map;",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getImmediateAppliedDirectivesByField",
+            "desc": "()Ljava/util/Map;",
+            "line": 137,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNormalizedInputValueByImmediateAppliedDirectives",
+            "desc": "()Ljava/util/Map;",
+            "line": 143,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getImmediateDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 149,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getImmediateAppliedDirectivesByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 155,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getImmediateDirective",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 161,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getImmediateAppliedDirective",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 167,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$computeValuesLazily$0",
+            "desc": "()V",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 19,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$computeValuesLazily$6",
+            "desc": "(Lcom/google/common/collect/BiMap;Lcom/google/common/collect/BiMap;Lgraphql/execution/NormalizedVariables;Ljava/util/Map;Ljava/util/List;)V",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$computeValuesLazily$2",
+            "desc": "(Ljava/util/Map;Lcom/google/common/collect/BiMap;Ljava/util/Map;Lgraphql/language/Field;Ljava/util/List;)V",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$computeValuesLazily$3",
+            "desc": "(Ljava/util/Map;Lcom/google/common/collect/BiMap;Ljava/util/Map;Lgraphql/schema/GraphQLDirective;)V",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$computeValuesLazily$5",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$computeValuesLazily$4",
+            "desc": "(Ljava/lang/String;)Ljava/util/List;",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$computeValuesLazily$1",
+            "desc": "(Lcom/google/common/collect/BiMap;Lcom/google/common/collect/BiMap;Ljava/util/Map;Ljava/util/Map;Lgraphql/language/Field;)V",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.directives.QueryAppliedDirectiveArgument$Builder": {
+        "line": {
+          "covered": 8,
+          "missed": 13
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 5
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/directives/QueryAppliedDirectiveArgument;)V",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 6
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "type",
+            "desc": "(Lgraphql/schema/GraphQLInputType;)Lgraphql/execution/directives/QueryAppliedDirectiveArgument$Builder;",
+            "line": 154,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "definition",
+            "desc": "(Lgraphql/language/Argument;)Lgraphql/execution/directives/QueryAppliedDirectiveArgument$Builder;",
+            "line": 159,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "valueLiteral",
+            "desc": "(Lgraphql/language/Value;)Lgraphql/execution/directives/QueryAppliedDirectiveArgument$Builder;",
+            "line": 171,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "valueProgrammatic",
+            "desc": "(Ljava/lang/Object;)Lgraphql/execution/directives/QueryAppliedDirectiveArgument$Builder;",
+            "line": 181,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "inputValueWithState",
+            "desc": "(Lgraphql/schema/InputValueWithState;)Lgraphql/execution/directives/QueryAppliedDirectiveArgument$Builder;",
+            "line": 186,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clearValue",
+            "desc": "()Lgraphql/execution/directives/QueryAppliedDirectiveArgument$Builder;",
+            "line": 196,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/execution/directives/QueryAppliedDirectiveArgument;",
+            "line": 202,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.directives.QueryDirectives": {
+        "line": {
+          "covered": 1,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "newQueryDirectives",
+            "desc": "()Lgraphql/execution/directives/QueryDirectives$Builder;",
+            "line": 113,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.directives.QueryAppliedDirective$Builder": {
+        "line": {
+          "covered": 7,
+          "missed": 19
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 2
+        },
+        "method": {
+          "covered": 3,
+          "missed": 6
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/directives/QueryAppliedDirective;)V",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 6
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "argument",
+            "desc": "(Lgraphql/execution/directives/QueryAppliedDirectiveArgument;)Lgraphql/execution/directives/QueryAppliedDirective$Builder;",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceArguments",
+            "desc": "(Ljava/util/List;)Lgraphql/execution/directives/QueryAppliedDirective$Builder;",
+            "line": 133,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 6
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "argument",
+            "desc": "(Ljava/util/function/UnaryOperator;)Lgraphql/execution/directives/QueryAppliedDirective$Builder;",
+            "line": 155,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "argument",
+            "desc": "(Lgraphql/execution/directives/QueryAppliedDirectiveArgument$Builder;)Lgraphql/execution/directives/QueryAppliedDirective$Builder;",
+            "line": 169,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "clearArguments",
+            "desc": "()Lgraphql/execution/directives/QueryAppliedDirective$Builder;",
+            "line": 178,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "definition",
+            "desc": "(Lgraphql/language/Directive;)Lgraphql/execution/directives/QueryAppliedDirective$Builder;",
+            "line": 184,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/execution/directives/QueryAppliedDirective;",
+            "line": 189,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.directives.DirectivesResolver": {
+        "line": {
+          "covered": 36,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 5,
+          "missed": 1
+        },
+        "method": {
+          "covered": 11,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "resolveDirectives",
+            "desc": "(Ljava/util/List;Lgraphql/schema/GraphQLSchema;Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)Lcom/google/common/collect/BiMap;",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildArguments",
+            "desc": "(Lgraphql/schema/GraphQLDirective$Builder;Lgraphql/schema/GraphQLCodeRegistry;Lgraphql/schema/GraphQLDirective;Lgraphql/language/Directive;Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)V",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toAppliedDirectives",
+            "desc": "(Ljava/util/List;Lgraphql/schema/GraphQLSchema;Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)Lcom/google/common/collect/ImmutableList;",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toAppliedDirective",
+            "desc": "(Lgraphql/schema/GraphQLDirective;)Lgraphql/execution/directives/QueryAppliedDirective;",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toAppliedArgument",
+            "desc": "(Lgraphql/schema/GraphQLArgument;)Lgraphql/execution/directives/QueryAppliedDirectiveArgument;",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildArguments$0",
+            "desc": "(Ljava/util/Map;Lgraphql/schema/GraphQLDirective$Builder;Lgraphql/schema/GraphQLArgument;)V",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildArguments$2",
+            "desc": "(Lgraphql/schema/GraphQLArgument$Builder;)V",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildArguments$1",
+            "desc": "(Ljava/lang/Object;Lgraphql/schema/GraphQLArgument$Builder;)V",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$resolveDirectives$0",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLCodeRegistry;Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;Lcom/google/common/collect/BiMap;Lgraphql/language/Directive;)V",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$resolveDirectives$1",
+            "desc": "(Lgraphql/schema/GraphQLCodeRegistry;Lgraphql/schema/GraphQLDirective;Lgraphql/language/Directive;Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;Lgraphql/schema/GraphQLDirective$Builder;)V",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.directives.QueryDirectivesBuilder": {
+        "line": {
+          "covered": 18,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 8,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "schema",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Lgraphql/execution/directives/QueryDirectives$Builder;",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mergedField",
+            "desc": "(Lgraphql/execution/MergedField;)Lgraphql/execution/directives/QueryDirectives$Builder;",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "field",
+            "desc": "(Lgraphql/language/Field;)Lgraphql/execution/directives/QueryDirectives$Builder;",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "coercedVariables",
+            "desc": "(Lgraphql/execution/CoercedVariables;)Lgraphql/execution/directives/QueryDirectives$Builder;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "normalizedVariables",
+            "desc": "(Ljava/util/function/Supplier;)Lgraphql/execution/directives/QueryDirectives$Builder;",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "graphQLContext",
+            "desc": "(Lgraphql/GraphQLContext;)Lgraphql/execution/directives/QueryDirectives$Builder;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "locale",
+            "desc": "(Ljava/util/Locale;)Lgraphql/execution/directives/QueryDirectives$Builder;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/execution/directives/QueryDirectives;",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.directives.OperationDirectivesResolver": {
+        "line": {
+          "covered": 13,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "resolveDirectives",
+            "desc": "(Lgraphql/language/Document;Lgraphql/schema/GraphQLSchema;Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)Lcom/google/common/collect/ImmutableMap;",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "resolveDirectives",
+            "desc": "(Lgraphql/language/OperationDefinition;Lgraphql/schema/GraphQLSchema;Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)Lcom/google/common/collect/ImmutableList;",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "resolveDirectivesByName",
+            "desc": "(Lgraphql/language/OperationDefinition;Lgraphql/schema/GraphQLSchema;Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)Lcom/google/common/collect/ImmutableMap;",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toAppliedDirectivesByName",
+            "desc": "(Ljava/util/List;)Lcom/google/common/collect/ImmutableMap;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.parameters.InstrumentationReactiveResultsParameters": {
+        "line": {
+          "covered": 5,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/instrumentation/parameters/InstrumentationReactiveResultsParameters$ResultType;)V",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExecutionContext",
+            "desc": "()Lgraphql/execution/ExecutionContext;",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getResultType",
+            "desc": "()Lgraphql/execution/instrumentation/parameters/InstrumentationReactiveResultsParameters$ResultType;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.parameters.InstrumentationExecutionParameters": {
+        "line": {
+          "covered": 10,
+          "missed": 6
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 6
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/ExecutionInput;Lgraphql/schema/GraphQLSchema;)V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExecutionInput",
+            "desc": "()Lgraphql/ExecutionInput;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getQuery",
+            "desc": "()Ljava/lang/String;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getOperation",
+            "desc": "()Ljava/lang/String;",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getContext",
+            "desc": "()Ljava/lang/Object;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getGraphQLContext",
+            "desc": "()Lgraphql/GraphQLContext;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getVariables",
+            "desc": "()Ljava/util/Map;",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getSchema",
+            "desc": "()Lgraphql/schema/GraphQLSchema;",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.parameters.InstrumentationValidationParameters": {
+        "line": {
+          "covered": 3,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/ExecutionInput;Lgraphql/language/Document;Lgraphql/schema/GraphQLSchema;)V",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDocument",
+            "desc": "()Lgraphql/language/Document;",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.parameters.InstrumentationExecuteOperationParameters": {
+        "line": {
+          "covered": 4,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/ExecutionContext;)V",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExecutionContext",
+            "desc": "()Lgraphql/execution/ExecutionContext;",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.parameters.InstrumentationFieldFetchParameters": {
+        "line": {
+          "covered": 7,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/ExecutionContext;Ljava/util/function/Supplier;Lgraphql/execution/ExecutionStrategyParameters;Z)V",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getEnvironment",
+            "desc": "()Lgraphql/schema/DataFetchingEnvironment;",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isTrivialDataFetcher",
+            "desc": "()Z",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$new$0",
+            "desc": "(Ljava/util/function/Supplier;)Lgraphql/execution/ExecutionStepInfo;",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.parameters.InstrumentationCreateStateParameters": {
+        "line": {
+          "covered": 5,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/ExecutionInput;)V",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSchema",
+            "desc": "()Lgraphql/schema/GraphQLSchema;",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getExecutionInput",
+            "desc": "()Lgraphql/ExecutionInput;",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.parameters.InstrumentationReactiveResultsParameters$ResultType": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.parameters.InstrumentationFieldCompleteParameters": {
+        "line": {
+          "covered": 9,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Ljava/util/function/Supplier;Ljava/lang/Object;)V",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExecutionContext",
+            "desc": "()Lgraphql/execution/ExecutionContext;",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getExecutionStrategyParameters",
+            "desc": "()Lgraphql/execution/ExecutionStrategyParameters;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getField",
+            "desc": "()Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTypeInfo",
+            "desc": "()Lgraphql/execution/ExecutionStepInfo;",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getExecutionStepInfo",
+            "desc": "()Lgraphql/execution/ExecutionStepInfo;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFetchedObject",
+            "desc": "()Ljava/lang/Object;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.parameters.InstrumentationFieldParameters": {
+        "line": {
+          "covered": 5,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/ExecutionContext;Ljava/util/function/Supplier;)V",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExecutionContext",
+            "desc": "()Lgraphql/execution/ExecutionContext;",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getField",
+            "desc": "()Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExecutionStepInfo",
+            "desc": "()Lgraphql/execution/ExecutionStepInfo;",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.instrumentation.parameters.InstrumentationExecutionStrategyParameters": {
+        "line": {
+          "covered": 4,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;)V",
+            "line": 18,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExecutionContext",
+            "desc": "()Lgraphql/execution/ExecutionContext;",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getExecutionStrategyParameters",
+            "desc": "()Lgraphql/execution/ExecutionStrategyParameters;",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.UnresolvedTypeException": {
+        "line": {
+          "covered": 9,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/schema/GraphQLNamedOutputType;)V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLNamedOutputType;)V",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLNamedOutputType;Lgraphql/schema/GraphQLType;)V",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInterfaceOrUnionType",
+            "desc": "()Lgraphql/schema/GraphQLNamedOutputType;",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.ResultNodesInfo": {
+        "line": {
+          "covered": 8,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "incrementAndGetResultNodesCount",
+            "desc": "()I",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "maxResultNodesExceeded",
+            "desc": "()V",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getResultNodesCount",
+            "desc": "()I",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isMaxResultNodesExceeded",
+            "desc": "()Z",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.UnknownOperationException": {
+        "line": {
+          "covered": 2,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocations",
+            "desc": "()Ljava/util/List;",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/ErrorClassification;",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.DataFetcherExceptionHandlerParameters": {
+        "line": {
+          "covered": 11,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 8,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/DataFetcherExceptionHandlerParameters$Builder;)V",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getException",
+            "desc": "()Ljava/lang/Throwable;",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPath",
+            "desc": "()Lgraphql/execution/ResultPath;",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDataFetchingEnvironment",
+            "desc": "()Lgraphql/schema/DataFetchingEnvironment;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getField",
+            "desc": "()Lgraphql/execution/MergedField;",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinition",
+            "desc": "()Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentValues",
+            "desc": "()Ljava/util/Map;",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getSourceLocation",
+            "desc": "()Lgraphql/language/SourceLocation;",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newExceptionParameters",
+            "desc": "()Lgraphql/execution/DataFetcherExceptionHandlerParameters$Builder;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.OneOfNullValueException": {
+        "line": {
+          "covered": 2,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 21,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocations",
+            "desc": "()Ljava/util/List;",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/ErrorType;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.MergedSelectionSet": {
+        "line": {
+          "covered": 11,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 8,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Map;)V",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSubFields",
+            "desc": "()Ljava/util/Map;",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSubFieldsList",
+            "desc": "()Ljava/util/List;",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "size",
+            "desc": "()I",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "keySet",
+            "desc": "()Ljava/util/Set;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSubField",
+            "desc": "(Ljava/lang/String;)Lgraphql/execution/MergedField;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getKeys",
+            "desc": "()Ljava/util/List;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEmpty",
+            "desc": "()Z",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "newMergedSelectionSet",
+            "desc": "()Lgraphql/execution/MergedSelectionSet$Builder;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.ExecutionStepInfo": {
+        "line": {
+          "covered": 42,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 5,
+          "missed": 1
+        },
+        "method": {
+          "covered": 21,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/ExecutionStepInfo$Builder;)V",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLOutputType;Lgraphql/execution/ResultPath;Lgraphql/execution/ExecutionStepInfo;Lgraphql/execution/MergedField;Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/GraphQLObjectType;Ljava/util/function/Supplier;)V",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getObjectType",
+            "desc": "()Lgraphql/schema/GraphQLObjectType;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getType",
+            "desc": "()Lgraphql/schema/GraphQLOutputType;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getUnwrappedNonNullType",
+            "desc": "()Lgraphql/schema/GraphQLOutputType;",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getUnwrappedNonNullTypeAs",
+            "desc": "()Lgraphql/schema/GraphQLOutputType;",
+            "line": 142,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDefinition",
+            "desc": "()Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 152,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getField",
+            "desc": "()Lgraphql/execution/MergedField;",
+            "line": 161,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPath",
+            "desc": "()Lgraphql/execution/ResultPath;",
+            "line": 168,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isNonNullType",
+            "desc": "()Z",
+            "line": 175,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isListType",
+            "desc": "()Z",
+            "line": 182,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArguments",
+            "desc": "()Ljava/util/Map;",
+            "line": 189,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgument",
+            "desc": "(Ljava/lang/String;)Ljava/lang/Object;",
+            "line": 202,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParent",
+            "desc": "()Lgraphql/execution/ExecutionStepInfo;",
+            "line": 209,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasParent",
+            "desc": "()Z",
+            "line": 216,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "changeTypeWithPreservedNonNull",
+            "desc": "(Lgraphql/schema/GraphQLOutputType;)Lgraphql/execution/ExecutionStepInfo;",
+            "line": 230,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "simplePrint",
+            "desc": "()Ljava/lang/String;",
+            "line": 242,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 247,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Lgraphql/schema/GraphQLOutputType;)Lgraphql/execution/ExecutionStepInfo;",
+            "line": 256,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Lgraphql/schema/GraphQLOutputType;Lgraphql/execution/ExecutionStepInfo;Lgraphql/execution/ResultPath;)Lgraphql/execution/ExecutionStepInfo;",
+            "line": 261,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/execution/ExecutionStepInfo;",
+            "line": 265,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getResultKey",
+            "desc": "()Ljava/lang/String;",
+            "line": 271,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "newExecutionStepInfo",
+            "desc": "()Lgraphql/execution/ExecutionStepInfo$Builder;",
+            "line": 278,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newExecutionStepInfo",
+            "desc": "(Lgraphql/execution/ExecutionStepInfo;)Lgraphql/execution/ExecutionStepInfo$Builder;",
+            "line": 282,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.AsyncSerialExecutionStrategy": {
+        "line": {
+          "covered": 35,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/DataFetcherExceptionHandler;)V",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "execute",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "resolveSerialField",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/DataLoaderDispatchStrategy;Lgraphql/execution/ExecutionStrategyParameters;)Ljava/lang/Object;",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$resolveSerialField$0",
+            "desc": "(Lgraphql/execution/DataLoaderDispatchStrategy;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/execution/FieldValueInfo;)Ljava/util/concurrent/CompletionStage;",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$execute$0",
+            "desc": "(Lgraphql/execution/MergedSelectionSet;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/execution/ExecutionContext;Lgraphql/execution/DataLoaderDispatchStrategy;Ljava/lang/String;Ljava/util/List;)Ljava/lang/Object;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.Async$Many": {
+        "line": {
+          "covered": 51,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 23,
+          "missed": 1
+        },
+        "method": {
+          "covered": 9,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(I)V",
+            "line": 175,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "add",
+            "desc": "(Ljava/util/concurrent/CompletableFuture;)V",
+            "line": 183,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addObject",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 189,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "await",
+            "desc": "()Ljava/util/concurrent/CompletableFuture;",
+            "line": 198,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "copyOnlyCFsToArray",
+            "desc": "()[Ljava/util/concurrent/CompletableFuture;",
+            "line": 238,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "awaitPolymorphic",
+            "desc": "()Ljava/lang/Object;",
+            "line": 256,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "materialisedList",
+            "desc": "([Ljava/lang/Object;)Ljava/util/List;",
+            "line": 267,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "commonSizeAssert",
+            "desc": "()V",
+            "line": 271,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$commonSizeAssert$0",
+            "desc": "()Ljava/lang/String;",
+            "line": 271,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$await$0",
+            "desc": "(Ljava/util/concurrent/CompletableFuture;[Ljava/util/concurrent/CompletableFuture;Ljava/lang/Void;Ljava/lang/Throwable;)V",
+            "line": 207,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.TypeFromAST": {
+        "line": {
+          "covered": 7,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 8,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getTypeFromAST",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/Type;)Lgraphql/schema/GraphQLType;",
+            "line": 21,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.NonNullableFieldValidator": {
+        "line": {
+          "covered": 15,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 8,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/ExecutionContext;)V",
+            "line": 18,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validate",
+            "desc": "(Lgraphql/execution/ExecutionStrategyParameters;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.ResponseMapFactory": {
+        "line": {
+          "covered": 1,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.DataFetcherResult": {
+        "line": {
+          "covered": 21,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 10,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Object;Ljava/util/List;Ljava/lang/Object;Ljava/util/Map;)V",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getData",
+            "desc": "()Ljava/lang/Object;",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrors",
+            "desc": "()Ljava/util/List;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasErrors",
+            "desc": "()Z",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocalContext",
+            "desc": "()Ljava/lang/Object;",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/execution/DataFetcherResult;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "map",
+            "desc": "(Ljava/util/function/Function;)Lgraphql/execution/DataFetcherResult;",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 159,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "newResult",
+            "desc": "()Lgraphql/execution/DataFetcherResult$Builder;",
+            "line": 175,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newResult",
+            "desc": "(Ljava/lang/Object;)Lgraphql/execution/DataFetcherResult$Builder;",
+            "line": 188,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.RawVariables": {
+        "line": {
+          "covered": 10,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 8,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Map;)V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toMap",
+            "desc": "()Ljava/util/Map;",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "containsKey",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "get",
+            "desc": "(Ljava/lang/String;)Ljava/lang/Object;",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "emptyVariables",
+            "desc": "()Lgraphql/execution/RawVariables;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Ljava/util/Map;)Lgraphql/execution/RawVariables;",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.SimpleDataFetcherExceptionHandler": {
+        "line": {
+          "covered": 14,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleExceptionImpl",
+            "desc": "(Lgraphql/execution/DataFetcherExceptionHandlerParameters;)Lgraphql/execution/DataFetcherExceptionHandlerResult;",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleException",
+            "desc": "(Lgraphql/execution/DataFetcherExceptionHandlerParameters;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "logException",
+            "desc": "(Lgraphql/ExceptionWhileDataFetching;Ljava/lang/Throwable;)V",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unwrap",
+            "desc": "(Ljava/lang/Throwable;)Ljava/lang/Throwable;",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.Async": {
+        "line": {
+          "covered": 53,
+          "missed": 16
+        },
+        "branch": {
+          "covered": 19,
+          "missed": 1
+        },
+        "method": {
+          "covered": 10,
+          "missed": 9
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "ofExpectedSize",
+            "desc": "(I)Lgraphql/execution/Async$CombinedBuilder;",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "each",
+            "desc": "(Ljava/util/Collection;Ljava/util/function/Function;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 278,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "eachPolymorphic",
+            "desc": "(Ljava/util/Collection;Ljava/util/function/Function;)Ljava/lang/Object;",
+            "line": 299,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "eachSequentially",
+            "desc": "(Ljava/lang/Iterable;Ljava/util/function/BiFunction;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 315,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "eachSequentiallyPolymorphicImpl",
+            "desc": "(Ljava/util/Iterator;Ljava/util/function/BiFunction;Ljava/util/List;Ljava/util/concurrent/CompletableFuture;)V",
+            "line": 322,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toCompletableFuture",
+            "desc": "(Ljava/lang/Object;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 360,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toCompletableFutureOrMaterializedObject",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 376,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "tryCatch",
+            "desc": "(Ljava/util/function/Supplier;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 385,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 5
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "exceptionallyCompletedFuture",
+            "desc": "(Ljava/lang/Throwable;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 394,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "orNullCompletedFuture",
+            "desc": "(Ljava/util/concurrent/CompletableFuture;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 408,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "allOf",
+            "desc": "(Ljava/util/List;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 412,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "allOf",
+            "desc": "(Ljava/util/Map;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 420,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$allOf$3",
+            "desc": "(Ljava/util/Map;Ljava/lang/Void;)Ljava/util/Map;",
+            "line": 421,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$allOf$4",
+            "desc": "(Ljava/util/Map$Entry;)Ljava/lang/Object;",
+            "line": 425,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$allOf$2",
+            "desc": "(I)[Ljava/util/concurrent/CompletableFuture;",
+            "line": 420,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$allOf$1",
+            "desc": "(Ljava/util/List;Ljava/lang/Void;)Ljava/util/List;",
+            "line": 413,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$allOf$0",
+            "desc": "(I)[Ljava/util/concurrent/CompletableFuture;",
+            "line": 412,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$eachSequentiallyPolymorphicImpl$0",
+            "desc": "(Ljava/util/concurrent/CompletableFuture;Ljava/util/List;Ljava/util/Iterator;Ljava/util/function/BiFunction;Ljava/lang/Object;Ljava/lang/Throwable;)V",
+            "line": 336,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.AsyncExecutionStrategy": {
+        "line": {
+          "covered": 40,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 6,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/DataFetcherExceptionHandler;)V",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "execute",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 19,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$execute$1",
+            "desc": "(Lgraphql/execution/DataLoaderDispatchStrategy;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/execution/instrumentation/ExecutionStrategyInstrumentationContext;Ljava/util/concurrent/CompletableFuture;Ljava/lang/Throwable;)Ljava/util/List;",
+            "line": 89,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$execute$0",
+            "desc": "(Lgraphql/execution/incremental/DeferredExecutionSupport;Ljava/util/List;Lgraphql/execution/ExecutionContext;Ljava/util/concurrent/CompletableFuture;Lgraphql/execution/DataLoaderDispatchStrategy;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/execution/instrumentation/ExecutionStrategyInstrumentationContext;Ljava/util/List;Ljava/lang/Throwable;)V",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.AbortExecutionException": {
+        "line": {
+          "covered": 10,
+          "missed": 11
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 5
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Collection;)V",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/lang/Throwable;)V",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Throwable;)V",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getLocations",
+            "desc": "()Ljava/util/List;",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/ErrorType;",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getUnderlyingErrors",
+            "desc": "()Ljava/util/List;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toExecutionResult",
+            "desc": "()Lgraphql/ExecutionResult;",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.MergedField": {
+        "line": {
+          "covered": 26,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 6,
+          "missed": 2
+        },
+        "method": {
+          "covered": 17,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Field;Lcom/google/common/collect/ImmutableList;)V",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getName",
+            "desc": "()Ljava/lang/String;",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getResultKey",
+            "desc": "()Ljava/lang/String;",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSingleField",
+            "desc": "()Lgraphql/language/Field;",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArguments",
+            "desc": "()Ljava/util/List;",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFields",
+            "desc": "()Ljava/util/List;",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldsCount",
+            "desc": "()I",
+            "line": 134,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasSubSelection",
+            "desc": "()Z",
+            "line": 141,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isSingleField",
+            "desc": "()Z",
+            "line": 148,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDeferredExecutions",
+            "desc": "()Ljava/util/List;",
+            "line": 158,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isDeferred",
+            "desc": "()Z",
+            "line": 168,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "newMergedFieldWith",
+            "desc": "(Lgraphql/language/Field;Lgraphql/execution/incremental/DeferredExecution;)Lgraphql/execution/MergedField;",
+            "line": 205,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkDeferredExecutions",
+            "desc": "(Lgraphql/execution/incremental/DeferredExecution;)Lcom/google/common/collect/ImmutableList;",
+            "line": 211,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newMergedField",
+            "desc": "()Lgraphql/execution/MergedField$Builder;",
+            "line": 295,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newMergedField",
+            "desc": "(Lgraphql/language/Field;)Lgraphql/execution/MergedField$Builder;",
+            "line": 299,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newMergedField",
+            "desc": "(Ljava/util/Collection;)Lgraphql/execution/MergedField$Builder;",
+            "line": 303,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newSingletonMergedField",
+            "desc": "(Lgraphql/language/Field;Lgraphql/execution/incremental/DeferredExecution;)Lgraphql/execution/MergedField;",
+            "line": 317,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/execution/MergedField;",
+            "line": 321,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "forEach",
+            "desc": "(Ljava/util/function/Consumer;)V",
+            "line": 332,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.SubscriptionExecutionStrategy": {
+        "line": {
+          "covered": 81,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 9,
+          "missed": 1
+        },
+        "method": {
+          "covered": 21,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/DataFetcherExceptionHandler;)V",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "execute",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "keepOrdered",
+            "desc": "(Lgraphql/GraphQLContext;)Z",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createSourceEventStream",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkReactivePublisher",
+            "desc": "(Ljava/lang/Object;)Lorg/reactivestreams/Publisher;",
+            "line": 140,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executeSubscriptionEvent",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Ljava/lang/Object;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 168,
+            "counters": {
+              "line": {
+                "covered": 21,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "wrapWithRootFieldName",
+            "desc": "(Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/ExecutionResult;)Lgraphql/ExecutionResult;",
+            "line": 205,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getRootFieldName",
+            "desc": "(Lgraphql/execution/ExecutionStrategyParameters;)Ljava/lang/String;",
+            "line": 213,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "firstFieldOfSubscriptionSelection",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Z)Lgraphql/execution/ExecutionStrategyParameters;",
+            "line": 220,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createSubscribedFieldStepInfo",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;)Lgraphql/execution/ExecutionStepInfo;",
+            "line": 241,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$firstFieldOfSubscriptionSelection$0",
+            "desc": "(Lgraphql/execution/MergedField;Lgraphql/execution/ResultPath;Lgraphql/execution/NonNullableFieldValidator;ZLgraphql/execution/ExecutionStrategyParameters$Builder;)V",
+            "line": 228,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$executeSubscriptionEvent$4",
+            "desc": "(Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/instrumentation/parameters/InstrumentationExecutionParameters;Lgraphql/execution/ExecutionContext;Lgraphql/ExecutionResult;)Ljava/util/concurrent/CompletionStage;",
+            "line": 200,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$executeSubscriptionEvent$3",
+            "desc": "(Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/ExecutionResultImpl;)Lgraphql/ExecutionResult;",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$executeSubscriptionEvent$2",
+            "desc": "(Lgraphql/execution/ExecutionStrategyParameters;Ljava/lang/Object;)Lgraphql/ExecutionResultImpl;",
+            "line": 189,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$executeSubscriptionEvent$1",
+            "desc": "(Lgraphql/execution/ExecutionStepInfo;)Lgraphql/execution/ExecutionStepInfo;",
+            "line": 177,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$executeSubscriptionEvent$0",
+            "desc": "(Ljava/lang/Object;Lgraphql/execution/ExecutionContextBuilder;)V",
+            "line": 170,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$createSourceEventStream$0",
+            "desc": "(Ljava/lang/Object;)Lorg/reactivestreams/Publisher;",
+            "line": 125,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$execute$0",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Lorg/reactivestreams/Publisher;)Lgraphql/ExecutionResult;",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$execute$2",
+            "desc": "(Lgraphql/execution/instrumentation/InstrumentationContext;Ljava/lang/Throwable;)V",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$execute$1",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Ljava/lang/Object;)Ljava/util/concurrent/CompletionStage;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.Async$Empty": {
+        "line": {
+          "covered": 6,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 2
+        },
+        "method": {
+          "covered": 4,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "add",
+            "desc": "(Ljava/util/concurrent/CompletableFuture;)V",
+            "line": 93,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "addObject",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "await",
+            "desc": "()Ljava/util/concurrent/CompletableFuture;",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "awaitPolymorphic",
+            "desc": "()Ljava/lang/Object;",
+            "line": 109,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "typedEmpty",
+            "desc": "()Ljava/util/concurrent/CompletableFuture;",
+            "line": 118,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$awaitPolymorphic$0",
+            "desc": "()Ljava/lang/String;",
+            "line": 109,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.FieldCollectorParameters": {
+        "line": {
+          "covered": 13,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "getGraphQLSchema",
+            "desc": "()Lgraphql/schema/GraphQLSchema;",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFragmentsByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getVariables",
+            "desc": "()Ljava/util/Map;",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getObjectType",
+            "desc": "()Lgraphql/schema/GraphQLObjectType;",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getGraphQLContext",
+            "desc": "()Lgraphql/GraphQLContext;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/FieldCollectorParameters$Builder;)V",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newParameters",
+            "desc": "()Lgraphql/execution/FieldCollectorParameters$Builder;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.MergedField$MultiMergedField": {
+        "line": {
+          "covered": 15,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 2
+        },
+        "method": {
+          "covered": 7,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lcom/google/common/collect/ImmutableList;Lcom/google/common/collect/ImmutableList;)V",
+            "line": 226,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFields",
+            "desc": "()Ljava/util/List;",
+            "line": 232,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasSubSelection",
+            "desc": "()Z",
+            "line": 237,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldsCount",
+            "desc": "()I",
+            "line": 247,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isSingleField",
+            "desc": "()Z",
+            "line": 252,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 274,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "forEach",
+            "desc": "(Ljava/util/function/Consumer;)V",
+            "line": 282,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newMergedFieldWith",
+            "desc": "(Lgraphql/language/Field;Lgraphql/execution/incremental/DeferredExecution;)Lgraphql/execution/MergedField;",
+            "line": 287,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.FetchedValue": {
+        "line": {
+          "covered": 13,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "getFetchedValue",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocalContext",
+            "desc": "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Object;Ljava/util/List;Ljava/lang/Object;)V",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFetchedValue",
+            "desc": "()Ljava/lang/Object;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrors",
+            "desc": "()Ljava/util/List;",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocalContext",
+            "desc": "()Ljava/lang/Object;",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.ResultPath": {
+        "line": {
+          "covered": 91,
+          "missed": 14
+        },
+        "branch": {
+          "covered": 40,
+          "missed": 10
+        },
+        "method": {
+          "covered": 22,
+          "missed": 8
+        },
+        "methods": [
+          {
+            "name": "rootPath",
+            "desc": "()Lgraphql/execution/ResultPath;",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/ResultPath;Ljava/lang/String;)V",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/ResultPath;I)V",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "initString",
+            "desc": "()Ljava/lang/String;",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLevel",
+            "desc": "()I",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPathWithoutListEnd",
+            "desc": "()Lgraphql/execution/ResultPath;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isListSegment",
+            "desc": "()Z",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "isNamedSegment",
+            "desc": "()Z",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getSegmentName",
+            "desc": "()Ljava/lang/String;",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getSegmentIndex",
+            "desc": "()I",
+            "line": 108,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getSegmentValue",
+            "desc": "()Ljava/lang/Object;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getParent",
+            "desc": "()Lgraphql/execution/ResultPath;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "parse",
+            "desc": "(Ljava/lang/String;)Lgraphql/execution/ResultPath;",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 18,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 9,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fromList",
+            "desc": "(Ljava/util/List;)Lgraphql/execution/ResultPath;",
+            "line": 156,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkErrMsg",
+            "desc": "()Ljava/lang/String;",
+            "line": 171,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "segment",
+            "desc": "(Ljava/lang/String;)Lgraphql/execution/ResultPath;",
+            "line": 182,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "segment",
+            "desc": "(I)Lgraphql/execution/ResultPath;",
+            "line": 193,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "dropSegment",
+            "desc": "()Lgraphql/execution/ResultPath;",
+            "line": 202,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "replaceSegment",
+            "desc": "(I)Lgraphql/execution/ResultPath;",
+            "line": 217,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "replaceSegment",
+            "desc": "(Ljava/lang/String;)Lgraphql/execution/ResultPath;",
+            "line": 230,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isRootPath",
+            "desc": "()Z",
+            "line": 239,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "append",
+            "desc": "(Lgraphql/execution/ResultPath;)Lgraphql/execution/ResultPath;",
+            "line": 250,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sibling",
+            "desc": "(Ljava/lang/String;)Lgraphql/execution/ResultPath;",
+            "line": 257,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sibling",
+            "desc": "(I)Lgraphql/execution/ResultPath;",
+            "line": 262,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "toList",
+            "desc": "()Ljava/util/List;",
+            "line": 270,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getKeysOnly",
+            "desc": "()Ljava/util/List;",
+            "line": 286,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 306,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "segmentToString",
+            "desc": "()Ljava/lang/String;",
+            "line": 315,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.EngineRunningObserver$RunningState": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.FieldValueInfo$CompleteValueType": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.ExecutionContext": {
+        "line": {
+          "covered": 121,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 20,
+          "missed": 0
+        },
+        "method": {
+          "covered": 52,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/ExecutionContextBuilder;)V",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 37,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkExecutableNormalizedOperation",
+            "desc": "()Ljava/util/function/Supplier;",
+            "line": 121,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkOpDirectives",
+            "desc": "(Ljava/util/function/Supplier;)Ljava/util/function/Supplier;",
+            "line": 128,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExecutionId",
+            "desc": "()Lgraphql/execution/ExecutionId;",
+            "line": 135,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExecutionInput",
+            "desc": "()Lgraphql/ExecutionInput;",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInstrumentationState",
+            "desc": "()Lgraphql/execution/instrumentation/InstrumentationState;",
+            "line": 143,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInstrumentation",
+            "desc": "()Lgraphql/execution/instrumentation/Instrumentation;",
+            "line": 147,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getGraphQLSchema",
+            "desc": "()Lgraphql/schema/GraphQLSchema;",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFragmentsByName",
+            "desc": "()Ljava/util/Map;",
+            "line": 155,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDocument",
+            "desc": "()Lgraphql/language/Document;",
+            "line": 159,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOperationDefinition",
+            "desc": "()Lgraphql/language/OperationDefinition;",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOperationDirectives",
+            "desc": "()Ljava/util/Map;",
+            "line": 170,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAllOperationDirectives",
+            "desc": "()Ljava/util/Map;",
+            "line": 178,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCoercedVariables",
+            "desc": "()Lgraphql/execution/CoercedVariables;",
+            "line": 182,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNormalizedVariables",
+            "desc": "()Ljava/util/function/Supplier;",
+            "line": 189,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getContext",
+            "desc": "()Ljava/lang/Object;",
+            "line": 202,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getGraphQLContext",
+            "desc": "()Lgraphql/GraphQLContext;",
+            "line": 206,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocalContext",
+            "desc": "()Ljava/lang/Object;",
+            "line": 211,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getRoot",
+            "desc": "()Ljava/lang/Object;",
+            "line": 216,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFragment",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/FragmentDefinition;",
+            "line": 220,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDataLoaderRegistry",
+            "desc": "()Lorg/dataloader/DataLoaderRegistry;",
+            "line": 224,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocale",
+            "desc": "()Ljava/util/Locale;",
+            "line": 228,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getValueUnboxer",
+            "desc": "()Lgraphql/execution/ValueUnboxer;",
+            "line": 232,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "propagateErrorsOnNonNullContractFailure",
+            "desc": "()Z",
+            "line": 244,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isQueryOperation",
+            "desc": "()Z",
+            "line": 251,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isMutationOperation",
+            "desc": "()Z",
+            "line": 258,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isSubscriptionOperation",
+            "desc": "()Z",
+            "line": 265,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isOpType",
+            "desc": "(Lgraphql/language/OperationDefinition$Operation;)Z",
+            "line": 269,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addError",
+            "desc": "(Lgraphql/GraphQLError;Lgraphql/execution/ResultPath;)V",
+            "line": 282,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addError",
+            "desc": "(Lgraphql/GraphQLError;)V",
+            "line": 302,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addErrors",
+            "desc": "(Ljava/util/List;)V",
+            "line": 321,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getResponseMapFactory",
+            "desc": "()Lgraphql/execution/ResponseMapFactory;",
+            "line": 344,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrors",
+            "desc": "()Ljava/util/List;",
+            "line": 351,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getQueryStrategy",
+            "desc": "()Lgraphql/execution/ExecutionStrategy;",
+            "line": 355,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMutationStrategy",
+            "desc": "()Lgraphql/execution/ExecutionStrategy;",
+            "line": 359,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSubscriptionStrategy",
+            "desc": "()Lgraphql/execution/ExecutionStrategy;",
+            "line": 363,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getIncrementalCallState",
+            "desc": "()Lgraphql/execution/incremental/IncrementalCallState;",
+            "line": 367,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getStrategy",
+            "desc": "(Lgraphql/language/OperationDefinition$Operation;)Lgraphql/execution/ExecutionStrategy;",
+            "line": 371,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNormalizedQueryTree",
+            "desc": "()Ljava/util/function/Supplier;",
+            "line": 381,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setDataLoaderDispatcherStrategy",
+            "desc": "(Lgraphql/execution/DataLoaderDispatchStrategy;)V",
+            "line": 386,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDataLoaderDispatcherStrategy",
+            "desc": "()Lgraphql/execution/DataLoaderDispatchStrategy;",
+            "line": 391,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/execution/ExecutionContext;",
+            "line": 403,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getResultNodesInfo",
+            "desc": "()Lgraphql/execution/ResultNodesInfo;",
+            "line": 409,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasIncrementalSupport",
+            "desc": "()Z",
+            "line": 414,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getEngineRunningState",
+            "desc": "()Lgraphql/EngineRunningState;",
+            "line": 420,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "possibleCancellation",
+            "desc": "(Ljava/lang/Throwable;)Ljava/lang/Throwable;",
+            "line": 426,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getProfiler",
+            "desc": "()Lgraphql/Profiler;",
+            "line": 432,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "throwIfCancelled",
+            "desc": "()V",
+            "line": 437,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$addErrors$0",
+            "desc": "(Ljava/util/List;)V",
+            "line": 327,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$addError$1",
+            "desc": "(Lgraphql/GraphQLError;)V",
+            "line": 306,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$addError$0",
+            "desc": "(Lgraphql/execution/ResultPath;Lgraphql/GraphQLError;)V",
+            "line": 288,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$mkOpDirectives$0",
+            "desc": "(Ljava/util/function/Supplier;)Ljava/util/Map;",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$mkExecutableNormalizedOperation$0",
+            "desc": "()Lgraphql/normalized/ExecutableNormalizedOperation;",
+            "line": 122,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.NonNullableFieldWasNullError": {
+        "line": {
+          "covered": 9,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/NonNullableFieldWasNullException;)V",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMessage",
+            "desc": "()Ljava/lang/String;",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPath",
+            "desc": "()Ljava/util/List;",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocations",
+            "desc": "()Ljava/util/List;",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/ErrorType;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.CoercedVariables": {
+        "line": {
+          "covered": 9,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Map;)V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toMap",
+            "desc": "()Ljava/util/Map;",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "containsKey",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "get",
+            "desc": "(Ljava/lang/String;)Ljava/lang/Object;",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "emptyVariables",
+            "desc": "()Lgraphql/execution/CoercedVariables;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Ljava/util/Map;)Lgraphql/execution/CoercedVariables;",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 17,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.TypeResolutionParameters$Builder": {
+        "line": {
+          "covered": 20,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 12,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 94,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "field",
+            "desc": "(Lgraphql/execution/MergedField;)Lgraphql/execution/TypeResolutionParameters$Builder;",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldType",
+            "desc": "(Lgraphql/schema/GraphQLType;)Lgraphql/execution/TypeResolutionParameters$Builder;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "value",
+            "desc": "(Ljava/lang/Object;)Lgraphql/execution/TypeResolutionParameters$Builder;",
+            "line": 117,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "argumentValues",
+            "desc": "(Ljava/util/function/Supplier;)Lgraphql/execution/TypeResolutionParameters$Builder;",
+            "line": 122,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "schema",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Lgraphql/execution/TypeResolutionParameters$Builder;",
+            "line": 127,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "context",
+            "desc": "(Ljava/lang/Object;)Lgraphql/execution/TypeResolutionParameters$Builder;",
+            "line": 133,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "graphQLContext",
+            "desc": "(Lgraphql/GraphQLContext;)Lgraphql/execution/TypeResolutionParameters$Builder;",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "localContext",
+            "desc": "(Ljava/lang/Object;)Lgraphql/execution/TypeResolutionParameters$Builder;",
+            "line": 143,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "selectionSet",
+            "desc": "(Lgraphql/schema/DataFetchingFieldSelectionSet;)Lgraphql/execution/TypeResolutionParameters$Builder;",
+            "line": 148,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/TypeResolutionEnvironment;",
+            "line": 155,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$argumentValues$0",
+            "desc": "(Ljava/util/function/Supplier;)Lgraphql/collect/ImmutableMapWithNullValues;",
+            "line": 122,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.DataLoaderDispatchStrategy$1": {
+        "line": {
+          "covered": 1,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 14,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.NonNullableFieldWasNullException": {
+        "line": {
+          "covered": 23,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 6,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/ExecutionStepInfo;Lgraphql/execution/ResultPath;)V",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/NonNullableFieldWasNullException;)V",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkMessage",
+            "desc": "(Lgraphql/execution/ExecutionStepInfo;Lgraphql/execution/ResultPath;)Ljava/lang/String;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExecutionStepInfo",
+            "desc": "()Lgraphql/execution/ExecutionStepInfo;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPath",
+            "desc": "()Lgraphql/execution/ResultPath;",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.NormalizedVariables": {
+        "line": {
+          "covered": 6,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/Map;)V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toMap",
+            "desc": "()Ljava/util/Map;",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "containsKey",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "get",
+            "desc": "(Ljava/lang/String;)Ljava/lang/Object;",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "emptyVariables",
+            "desc": "()Lgraphql/execution/NormalizedVariables;",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "of",
+            "desc": "(Ljava/util/Map;)Lgraphql/execution/NormalizedVariables;",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.ExecutionStrategy": {
+        "line": {
+          "covered": 415,
+          "missed": 12
+        },
+        "branch": {
+          "covered": 90,
+          "missed": 10
+        },
+        "method": {
+          "covered": 62,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/DataFetcherExceptionHandler;)V",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkNameForPath",
+            "desc": "(Lgraphql/language/Field;)Ljava/lang/String;",
+            "line": 159,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkNameForPath",
+            "desc": "(Lgraphql/execution/MergedField;)Ljava/lang/String;",
+            "line": 164,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkNameForPath",
+            "desc": "(Ljava/util/List;)Ljava/lang/String;",
+            "line": 169,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executeObject",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;)Ljava/lang/Object;",
+            "line": 198,
+            "counters": {
+              "line": {
+                "covered": 34,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldValuesCombinedBuilder",
+            "desc": "(Ljava/util/List;)Lgraphql/execution/Async$CombinedBuilder;",
+            "line": 268,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildFieldValueMap",
+            "desc": "(Ljava/util/List;Ljava/util/concurrent/CompletableFuture;Lgraphql/execution/ExecutionContext;)Ljava/util/function/BiConsumer;",
+            "line": 276,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createDeferredExecutionSupport",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;)Lgraphql/execution/incremental/DeferredExecutionSupport;",
+            "line": 289,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getAsyncFieldValueInfo",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/execution/incremental/DeferredExecutionSupport;)Lgraphql/execution/Async$CombinedBuilder;",
+            "line": 307,
+            "counters": {
+              "line": {
+                "covered": 19,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "resolveFieldWithInfo",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;)Ljava/lang/Object;",
+            "line": 362,
+            "counters": {
+              "line": {
+                "covered": 18,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fetchField",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;)Ljava/lang/Object;",
+            "line": 411,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fetchField",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;)Ljava/lang/Object;",
+            "line": 419,
+            "counters": {
+              "line": {
+                "covered": 28,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "invokeDataFetcher",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/schema/GraphQLFieldDefinition;Ljava/util/function/Supplier;Lgraphql/schema/DataFetcher;Lgraphql/schema/DataFetcher;)Ljava/lang/Object;",
+            "line": 524,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNormalizedField",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Ljava/util/function/Supplier;)Ljava/util/function/Supplier;",
+            "line": 538,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unboxPossibleDataFetcherResult",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 557,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addExtensionsIfPresent",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/DataFetcherResult;)V",
+            "line": 577,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleFetchingException",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;Lgraphql/execution/ExecutionStrategyParameters;Ljava/lang/Throwable;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 591,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "asyncHandleException",
+            "desc": "(Lgraphql/execution/DataFetcherExceptionHandler;Lgraphql/execution/DataFetcherExceptionHandlerParameters;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 609,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "completeField",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Ljava/lang/Object;)Lgraphql/execution/FieldValueInfo;",
+            "line": 636,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "completeField",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Ljava/lang/Object;)Lgraphql/execution/FieldValueInfo;",
+            "line": 645,
+            "counters": {
+              "line": {
+                "covered": 17,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "completeValue",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;)Lgraphql/execution/FieldValueInfo;",
+            "line": 688,
+            "counters": {
+              "line": {
+                "covered": 20,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleUnresolvedTypeProblem",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/execution/UnresolvedTypeException;)V",
+            "line": 722,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldValueInfoForNull",
+            "desc": "(Lgraphql/execution/ExecutionStrategyParameters;)Lgraphql/execution/FieldValueInfo;",
+            "line": 737,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "completeValueForNull",
+            "desc": "(Lgraphql/execution/ExecutionStrategyParameters;)Ljava/lang/Object;",
+            "line": 753,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "completeValueForList",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Ljava/lang/Object;)Lgraphql/execution/FieldValueInfo;",
+            "line": 770,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "completeValueForList",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Ljava/lang/Iterable;)Lgraphql/execution/FieldValueInfo;",
+            "line": 794,
+            "counters": {
+              "line": {
+                "covered": 32,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleValueException",
+            "desc": "(Ljava/util/concurrent/CompletableFuture;Ljava/lang/Throwable;Lgraphql/execution/ExecutionContext;)V",
+            "line": 857,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "completeValueForScalar",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/schema/GraphQLScalarType;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 893,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "completeValueForEnum",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/schema/GraphQLEnumType;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 920,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "completeValueForObject",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/schema/GraphQLObjectType;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 944,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleCoercionProblem",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/schema/CoercingSerializeException;)Ljava/lang/Object;",
+            "line": 972,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "resolveType",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/schema/GraphQLType;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 981,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toIterable",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Ljava/lang/Object;)Ljava/lang/Iterable;",
+            "line": 988,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleTypeMismatchProblem",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;)V",
+            "line": 997,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "incrementAndCheckMaxNodesExceeded",
+            "desc": "(Lgraphql/execution/ExecutionContext;)Z",
+            "line": 1011,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDef",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/language/Field;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 1032,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDef",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLObjectType;Lgraphql/language/Field;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 1046,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "assertNonNullFieldPrecondition",
+            "desc": "(Lgraphql/execution/NonNullableFieldWasNullException;)V",
+            "line": 1064,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 4
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "assertNonNullFieldPrecondition",
+            "desc": "(Lgraphql/execution/NonNullableFieldWasNullException;Ljava/util/concurrent/CompletableFuture;)V",
+            "line": 1071,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleNonNullException",
+            "desc": "(Lgraphql/execution/ExecutionContext;Ljava/util/concurrent/CompletableFuture;Ljava/lang/Throwable;)Lgraphql/ExecutionResult;",
+            "line": 1078,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createExecutionStepInfo",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/GraphQLObjectType;)Lgraphql/execution/ExecutionStepInfo;",
+            "line": 1114,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createExecutionStepInfo",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;)Ljava/util/function/Supplier;",
+            "line": 1121,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addErrorToRightContext",
+            "desc": "(Lgraphql/GraphQLError;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/execution/ExecutionContext;)V",
+            "line": 1127,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addErrorsToRightContext",
+            "desc": "(Ljava/util/List;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/execution/ExecutionContext;)V",
+            "line": 1135,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$createExecutionStepInfo$0",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/schema/GraphQLFieldDefinition;)Lgraphql/execution/ExecutionStepInfo;",
+            "line": 1122,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$completeValueForList$1",
+            "desc": "(Lgraphql/execution/ExecutionContext;Ljava/util/concurrent/CompletableFuture;Ljava/util/List;Ljava/lang/Throwable;)V",
+            "line": 838,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$completeValueForList$0",
+            "desc": "(Lgraphql/execution/ExecutionStepInfo;)Lgraphql/execution/ExecutionStepInfo;",
+            "line": 797,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$completeField$0",
+            "desc": "(Lgraphql/execution/ExecutionStepInfo;)Lgraphql/execution/ExecutionStepInfo;",
+            "line": 649,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$asyncHandleException$0",
+            "desc": "(Lgraphql/execution/DataFetcherExceptionHandlerResult;)Lgraphql/execution/DataFetcherResult;",
+            "line": 610,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getNormalizedField$0",
+            "desc": "(Ljava/util/function/Supplier;Lgraphql/execution/ExecutionStrategyParameters;Ljava/util/function/Supplier;)Lgraphql/normalized/ExecutableNormalizedField;",
+            "line": 539,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$fetchField$5",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 509,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$fetchField$3",
+            "desc": "(Lgraphql/EngineRunningState;Ljava/util/function/Supplier;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/execution/instrumentation/FieldFetchingInstrumentationContext;Ljava/util/concurrent/CompletableFuture;Ljava/lang/Object;Ljava/lang/Throwable;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 492,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$fetchField$4",
+            "desc": "(Lgraphql/execution/instrumentation/FieldFetchingInstrumentationContext;Ljava/lang/Object;Ljava/lang/Throwable;Lgraphql/execution/DataFetcherResult;)Ljava/lang/Object;",
+            "line": 497,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$fetchField$0",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/GraphQLObjectType;Lgraphql/execution/MergedField;)Lgraphql/schema/DataFetchingEnvironment;",
+            "line": 432,
+            "counters": {
+              "line": {
+                "covered": 24,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$fetchField$2",
+            "desc": "(Ljava/util/function/Supplier;)Ljava/util/Map;",
+            "line": 435,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$fetchField$1",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/GraphQLObjectType;)Lgraphql/execution/ExecutionStepInfo;",
+            "line": 433,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$resolveFieldWithInfo$1",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/schema/GraphQLFieldDefinition;Ljava/lang/Object;)Lgraphql/execution/FieldValueInfo;",
+            "line": 374,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$resolveFieldWithInfo$0",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/schema/GraphQLFieldDefinition;)Lgraphql/execution/ExecutionStepInfo;",
+            "line": 363,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$createDeferredExecutionSupport$0",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 296,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildFieldValueMap$0",
+            "desc": "(Lgraphql/execution/ExecutionContext;Ljava/util/concurrent/CompletableFuture;Ljava/util/List;Ljava/util/List;Ljava/lang/Throwable;)V",
+            "line": 277,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$executeObject$1",
+            "desc": "(Lgraphql/execution/DataLoaderDispatchStrategy;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/execution/instrumentation/ExecuteObjectInstrumentationContext;Ljava/util/concurrent/CompletableFuture;Ljava/lang/Throwable;)Ljava/util/List;",
+            "line": 239,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$executeObject$0",
+            "desc": "(Lgraphql/execution/ExecutionContext;Ljava/util/function/BiConsumer;Lgraphql/execution/DataLoaderDispatchStrategy;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/execution/instrumentation/ExecuteObjectInstrumentationContext;Ljava/util/List;Ljava/lang/Throwable;)V",
+            "line": 224,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.ValuesResolverConversion": {
+        "line": {
+          "covered": 231,
+          "missed": 24
+        },
+        "branch": {
+          "covered": 138,
+          "missed": 24
+        },
+        "method": {
+          "covered": 21,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "valueToLiteralImpl",
+            "desc": "(Lgraphql/schema/visibility/GraphqlFieldVisibility;Lgraphql/schema/InputValueWithState;Lgraphql/schema/GraphQLType;Lgraphql/execution/ValuesResolver$ValueMode;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "externalValueToInternalValue",
+            "desc": "(Lgraphql/schema/visibility/GraphqlFieldVisibility;Ljava/lang/Object;Lgraphql/schema/GraphQLInputType;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "valueToInternalValueImpl",
+            "desc": "(Lgraphql/execution/values/InputInterceptor;Lgraphql/schema/InputValueWithState;Lgraphql/schema/GraphQLInputType;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 132,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "externalValueToLiteral",
+            "desc": "(Lgraphql/schema/visibility/GraphqlFieldVisibility;Ljava/lang/Object;Lgraphql/schema/GraphQLInputType;Lgraphql/execution/ValuesResolver$ValueMode;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 170,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 9,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "externalValueToLiteralForScalar",
+            "desc": "(Lgraphql/schema/GraphQLScalarType;Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Lgraphql/language/Value;",
+            "line": 224,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "externalValueToLiteralForEnum",
+            "desc": "(Lgraphql/schema/GraphQLEnumType;Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Lgraphql/language/Value;",
+            "line": 236,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "externalValueToLiteralForList",
+            "desc": "(Lgraphql/schema/visibility/GraphqlFieldVisibility;Lgraphql/schema/GraphQLList;Ljava/lang/Object;Lgraphql/execution/ValuesResolver$ValueMode;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 254,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "externalValueToLiteralForObject",
+            "desc": "(Lgraphql/schema/visibility/GraphqlFieldVisibility;Lgraphql/schema/GraphQLInputObjectType;Ljava/lang/Object;Lgraphql/execution/ValuesResolver$ValueMode;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 287,
+            "counters": {
+              "line": {
+                "covered": 21,
+                "missed": 8
+              },
+              "branch": {
+                "covered": 9,
+                "missed": 9
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "externalValueToInternalValueForVariables",
+            "desc": "(Lgraphql/execution/values/InputInterceptor;Lgraphql/schema/GraphQLSchema;Ljava/util/List;Lgraphql/execution/RawVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)Lgraphql/execution/CoercedVariables;",
+            "line": 350,
+            "counters": {
+              "line": {
+                "covered": 33,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 16,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "externalValueToInternalValueImpl",
+            "desc": "(Lgraphql/execution/values/InputInterceptor;Lgraphql/schema/visibility/GraphqlFieldVisibility;Lgraphql/schema/GraphQLInputType;Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 412,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "externalValueToInternalValueImpl",
+            "desc": "(Ljava/lang/String;Lgraphql/execution/values/InputInterceptor;Lgraphql/schema/visibility/GraphqlFieldVisibility;Lgraphql/schema/GraphQLInputType;Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 433,
+            "counters": {
+              "line": {
+                "covered": 26,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 17,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "externalValueToInternalValueForObject",
+            "desc": "(Lgraphql/execution/values/InputInterceptor;Lgraphql/schema/visibility/GraphqlFieldVisibility;Lgraphql/schema/GraphQLInputObjectType;Ljava/util/Map;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/util/Map;",
+            "line": 516,
+            "counters": {
+              "line": {
+                "covered": 25,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 20,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "externalValueToInternalValueForScalar",
+            "desc": "(Lgraphql/schema/GraphQLScalarType;Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 570,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "externalValueToInternalValueForEnum",
+            "desc": "(Lgraphql/schema/GraphQLEnumType;Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 585,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "externalValueToInternalValueForList",
+            "desc": "(Lgraphql/execution/values/InputInterceptor;Lgraphql/schema/visibility/GraphqlFieldVisibility;Lgraphql/schema/GraphQLList;Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/util/List;",
+            "line": 603,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "literalToInternalValue",
+            "desc": "(Lgraphql/execution/values/InputInterceptor;Lgraphql/schema/visibility/GraphqlFieldVisibility;Lgraphql/schema/GraphQLInputType;Lgraphql/language/Value;Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 639,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "literalToInternalValueImpl",
+            "desc": "(Lgraphql/execution/values/InputInterceptor;Lgraphql/schema/visibility/GraphqlFieldVisibility;Lgraphql/schema/GraphQLType;Lgraphql/language/Value;Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 659,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 13,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "literalToInternalValueForScalar",
+            "desc": "(Lgraphql/language/Value;Lgraphql/schema/GraphQLScalarType;Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 721,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "literalToInternalValueForList",
+            "desc": "(Lgraphql/execution/values/InputInterceptor;Lgraphql/schema/visibility/GraphqlFieldVisibility;Lgraphql/schema/GraphQLList;Lgraphql/language/Value;Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 741,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "literalToInternalValueForInputObject",
+            "desc": "(Lgraphql/execution/values/InputInterceptor;Lgraphql/schema/visibility/GraphqlFieldVisibility;Lgraphql/schema/GraphQLInputObjectType;Lgraphql/language/ObjectValue;Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 781,
+            "counters": {
+              "line": {
+                "covered": 29,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 22,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isNullValue",
+            "desc": "(Ljava/lang/Object;)Z",
+            "line": 834,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mapObjectValueFieldsByName",
+            "desc": "(Lgraphql/language/ObjectValue;)Ljava/util/Map;",
+            "line": 844,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "defaultValueToInternalValue",
+            "desc": "(Lgraphql/execution/values/InputInterceptor;Lgraphql/schema/visibility/GraphqlFieldVisibility;Lgraphql/schema/InputValueWithState;Lgraphql/schema/GraphQLInputType;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 859,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.ValuesResolverLegacy": {
+        "line": {
+          "covered": 50,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 32,
+          "missed": 4
+        },
+        "method": {
+          "covered": 7,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "valueToLiteralLegacy",
+            "desc": "(Ljava/lang/Object;Lgraphql/schema/GraphQLType;Lgraphql/GraphQLContext;Ljava/util/Locale;)Lgraphql/language/Value;",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 22,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 23,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleInputObjectLegacy",
+            "desc": "(Ljava/lang/Object;Lgraphql/schema/GraphQLInputObjectType;Lgraphql/GraphQLContext;Ljava/util/Locale;)Lgraphql/language/Value;",
+            "line": 109,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleNumberLegacy",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/Value;",
+            "line": 124,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleListLegacy",
+            "desc": "(Ljava/lang/Object;Lgraphql/schema/GraphQLList;Lgraphql/GraphQLContext;Ljava/util/Locale;)Lgraphql/language/Value;",
+            "line": 133,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleNonNullLegacy",
+            "desc": "(Ljava/lang/Object;Lgraphql/schema/GraphQLNonNull;Lgraphql/GraphQLContext;Ljava/util/Locale;)Lgraphql/language/Value;",
+            "line": 146,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "serializeLegacy",
+            "desc": "(Lgraphql/schema/GraphQLType;Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 151,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$handleInputObjectLegacy$0",
+            "desc": "(Ljava/lang/Object;Lgraphql/GraphQLContext;Ljava/util/Locale;Ljava/util/List;Lgraphql/schema/GraphQLInputObjectField;)V",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.ExecutionStepInfoFactory": {
+        "line": {
+          "covered": 29,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newExecutionStepInfoForListElement",
+            "desc": "(Lgraphql/execution/ExecutionStepInfo;Lgraphql/execution/ResultPath;)Lgraphql/execution/ExecutionStepInfo;",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createExecutionStepInfo",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/schema/GraphQLFieldDefinition;Lgraphql/schema/GraphQLObjectType;)Lgraphql/execution/ExecutionStepInfo;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentValues",
+            "desc": "(Lgraphql/execution/ExecutionContext;Ljava/util/List;Ljava/util/List;)Ljava/util/function/Supplier;",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getArgumentValues$0",
+            "desc": "(Lgraphql/schema/GraphQLCodeRegistry;Ljava/util/List;Ljava/util/List;Lgraphql/execution/ExecutionContext;)Lgraphql/collect/ImmutableMapWithNullValues;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.TypeResolutionParameters": {
+        "line": {
+          "covered": 21,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 11,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/TypeResolutionParameters$Builder;)V",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getField",
+            "desc": "()Lgraphql/execution/MergedField;",
+            "line": 48,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldType",
+            "desc": "()Lgraphql/schema/GraphQLType;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getValue",
+            "desc": "()Ljava/lang/Object;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentValues",
+            "desc": "()Ljava/util/Map;",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSchema",
+            "desc": "()Lgraphql/schema/GraphQLSchema;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSelectionSet",
+            "desc": "()Lgraphql/schema/DataFetchingFieldSelectionSet;",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newParameters",
+            "desc": "()Lgraphql/execution/TypeResolutionParameters$Builder;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getContext",
+            "desc": "()Ljava/lang/Object;",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getGraphQLContext",
+            "desc": "()Lgraphql/GraphQLContext;",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocalContext",
+            "desc": "()Ljava/lang/Object;",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.Async$Single": {
+        "line": {
+          "covered": 18,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 5,
+          "missed": 1
+        },
+        "method": {
+          "covered": 5,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "add",
+            "desc": "(Ljava/util/concurrent/CompletableFuture;)V",
+            "line": 130,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addObject",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "await",
+            "desc": "()Ljava/util/concurrent/CompletableFuture;",
+            "line": 142,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "awaitPolymorphic",
+            "desc": "()Ljava/lang/Object;",
+            "line": 154,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "commonSizeAssert",
+            "desc": "()V",
+            "line": 165,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$commonSizeAssert$0",
+            "desc": "()Ljava/lang/String;",
+            "line": 165,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.DataLoaderDispatchStrategy": {
+        "line": {
+          "covered": 16,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 16,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "executionStrategy",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;I)V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executionSerialStrategy",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;)V",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executionStrategyOnFieldValuesInfo",
+            "desc": "(Ljava/util/List;Lgraphql/execution/ExecutionStrategyParameters;)V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executionStrategyOnFieldValuesException",
+            "desc": "(Ljava/lang/Throwable;Lgraphql/execution/ExecutionStrategyParameters;)V",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executeObject",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;I)V",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executeObjectOnFieldValuesInfo",
+            "desc": "(Ljava/util/List;Lgraphql/execution/ExecutionStrategyParameters;)V",
+            "line": 41,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deferredOnFieldValue",
+            "desc": "(Ljava/lang/String;Lgraphql/execution/FieldValueInfo;Ljava/lang/Throwable;Lgraphql/execution/ExecutionStrategyParameters;)V",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executeObjectOnFieldValuesException",
+            "desc": "(Ljava/lang/Throwable;Lgraphql/execution/ExecutionStrategyParameters;)V",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldFetched",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/schema/DataFetcher;Ljava/lang/Object;Ljava/util/function/Supplier;)V",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newSubscriptionExecution",
+            "desc": "(Lgraphql/execution/incremental/AlternativeCallContext;)V",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "subscriptionEventCompletionDone",
+            "desc": "(Lgraphql/execution/incremental/AlternativeCallContext;)V",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "finishedFetching",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategyParameters;)V",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deferFieldFetched",
+            "desc": "(Lgraphql/execution/ExecutionStrategyParameters;)V",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "startComplete",
+            "desc": "(Lgraphql/execution/ExecutionStrategyParameters;)V",
+            "line": 78,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "stopComplete",
+            "desc": "(Lgraphql/execution/ExecutionStrategyParameters;)V",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 14,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.OneOfTooManyKeysException": {
+        "line": {
+          "covered": 2,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 21,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocations",
+            "desc": "()Ljava/util/List;",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/ErrorType;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.FieldCollectorParameters$Builder": {
+        "line": {
+          "covered": 15,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "schema",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Lgraphql/execution/FieldCollectorParameters$Builder;",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "objectType",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;)Lgraphql/execution/FieldCollectorParameters$Builder;",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "graphQLContext",
+            "desc": "(Lgraphql/GraphQLContext;)Lgraphql/execution/FieldCollectorParameters$Builder;",
+            "line": 80,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fragments",
+            "desc": "(Ljava/util/Map;)Lgraphql/execution/FieldCollectorParameters$Builder;",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "variables",
+            "desc": "(Ljava/util/Map;)Lgraphql/execution/FieldCollectorParameters$Builder;",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/execution/FieldCollectorParameters;",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.MergedSelectionSet$Builder": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "subFields",
+            "desc": "(Ljava/util/Map;)Lgraphql/execution/MergedSelectionSet$Builder;",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/execution/MergedSelectionSet;",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.FieldValueInfo": {
+        "line": {
+          "covered": 13,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/FieldValueInfo$CompleteValueType;Ljava/lang/Object;)V",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/FieldValueInfo$CompleteValueType;Ljava/lang/Object;Ljava/util/List;)V",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getCompleteValueType",
+            "desc": "()Lgraphql/execution/FieldValueInfo$CompleteValueType;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldValueObject",
+            "desc": "()Ljava/lang/Object;",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldValueFuture",
+            "desc": "()Ljava/util/concurrent/CompletableFuture;",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isFutureValue",
+            "desc": "()Z",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldValueInfos",
+            "desc": "()Ljava/util/List;",
+            "line": 92,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 98,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.DataFetcherExceptionHandlerResult$Builder": {
+        "line": {
+          "covered": 7,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "errors",
+            "desc": "(Ljava/util/List;)Lgraphql/execution/DataFetcherExceptionHandlerResult$Builder;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "error",
+            "desc": "(Lgraphql/GraphQLError;)Lgraphql/execution/DataFetcherExceptionHandlerResult$Builder;",
+            "line": 49,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/execution/DataFetcherExceptionHandlerResult;",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.NonNullableValueCoercedAsNullException": {
+        "line": {
+          "covered": 17,
+          "missed": 17
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 5
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/VariableDefinition;Lgraphql/schema/GraphQLType;)V",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/VariableDefinition;Ljava/lang/String;Lgraphql/schema/GraphQLType;)V",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/VariableDefinition;Ljava/lang/String;Ljava/util/List;Lgraphql/schema/GraphQLType;)V",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 5
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLType;)V",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/VariableDefinition;Ljava/lang/String;)V",
+            "line": 54,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/List;Lgraphql/schema/GraphQLType;)V",
+            "line": 59,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;)V",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;Ljava/util/List;)V",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLArgument;)V",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocations",
+            "desc": "()Ljava/util/List;",
+            "line": 81,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPath",
+            "desc": "()Ljava/util/List;",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/ErrorType;",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.ValuesResolverOneOfValidation": {
+        "line": {
+          "covered": 45,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 30,
+          "missed": 2
+        },
+        "method": {
+          "covered": 5,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "validateOneOfInputTypes",
+            "desc": "(Lgraphql/schema/GraphQLType;Ljava/lang/Object;Lgraphql/language/Value;Ljava/lang/String;Ljava/util/Locale;)V",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 30,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 22,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateOneOfInputTypesInternal",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;Lgraphql/language/Value;Ljava/util/Map;Ljava/util/Locale;)V",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "throwValueIsNullError",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;Ljava/util/Locale;Ljava/lang/String;)V",
+            "line": 100,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "throwNotOneFieldError",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;Ljava/util/Locale;)V",
+            "line": 106,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$validateOneOfInputTypes$0",
+            "desc": "(Ljava/lang/String;Lgraphql/language/ObjectField;)Z",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.ExecutionIdProvider": {
+        "line": {
+          "covered": 1,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "lambda$static$0",
+            "desc": "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/Object;)Lgraphql/execution/ExecutionId;",
+            "line": 11,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 11,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.ValuesResolver$ValueMode": {
+        "line": {
+          "covered": 3,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.MissingRootTypeException": {
+        "line": {
+          "covered": 5,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 1,
+          "missed": 1
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Lgraphql/language/SourceLocation;)V",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocations",
+            "desc": "()Ljava/util/List;",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/ErrorType;",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.DataFetcherExceptionHandlerResult": {
+        "line": {
+          "covered": 6,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/DataFetcherExceptionHandlerResult$Builder;)V",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrors",
+            "desc": "()Ljava/util/List;",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newResult",
+            "desc": "()Lgraphql/execution/DataFetcherExceptionHandlerResult$Builder;",
+            "line": 31,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newResult",
+            "desc": "(Lgraphql/GraphQLError;)Lgraphql/execution/DataFetcherExceptionHandlerResult$Builder;",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.ResolveType": {
+        "line": {
+          "covered": 30,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 9,
+          "missed": 1
+        },
+        "method": {
+          "covered": 7,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 21,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "resolveType",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/MergedField;Ljava/lang/Object;Lgraphql/execution/ExecutionStepInfo;Lgraphql/schema/GraphQLType;Ljava/lang/Object;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildSelectionSet",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/MergedField;Lgraphql/schema/GraphQLOutputType;Lgraphql/execution/ExecutionStepInfo;)Lgraphql/schema/DataFetchingFieldSelectionSet;",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "resolveTypeForInterface",
+            "desc": "(Lgraphql/TypeResolutionEnvironment;Lgraphql/schema/GraphQLInterfaceType;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "resolveTypeForUnion",
+            "desc": "(Lgraphql/TypeResolutionEnvironment;Lgraphql/schema/GraphQLUnionType;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "resolveAbstractType",
+            "desc": "(Lgraphql/TypeResolutionEnvironment;Lgraphql/schema/TypeResolver;Lgraphql/schema/GraphQLNamedOutputType;)Lgraphql/schema/GraphQLObjectType;",
+            "line": 62,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$buildSelectionSet$0",
+            "desc": "(Ljava/util/function/Supplier;Lgraphql/execution/MergedField;Lgraphql/execution/ExecutionStepInfo;)Lgraphql/normalized/ExecutableNormalizedField;",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$resolveType$0",
+            "desc": "(Lgraphql/schema/GraphQLType;)Ljava/lang/String;",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.DataFetcherResult$Builder": {
+        "line": {
+          "covered": 26,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 11,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/DataFetcherResult;)V",
+            "line": 194,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/Object;)V",
+            "line": 194,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 194,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "data",
+            "desc": "(Ljava/lang/Object;)Lgraphql/execution/DataFetcherResult$Builder;",
+            "line": 212,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "errors",
+            "desc": "(Ljava/util/List;)Lgraphql/execution/DataFetcherResult$Builder;",
+            "line": 217,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "error",
+            "desc": "(Lgraphql/GraphQLError;)Lgraphql/execution/DataFetcherResult$Builder;",
+            "line": 222,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "clearErrors",
+            "desc": "()Lgraphql/execution/DataFetcherResult$Builder;",
+            "line": 227,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasErrors",
+            "desc": "()Z",
+            "line": 235,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "localContext",
+            "desc": "(Ljava/lang/Object;)Lgraphql/execution/DataFetcherResult$Builder;",
+            "line": 239,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "extensions",
+            "desc": "(Ljava/util/Map;)Lgraphql/execution/DataFetcherResult$Builder;",
+            "line": 244,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/execution/DataFetcherResult;",
+            "line": 249,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.DefaultResponseMapFactory": {
+        "line": {
+          "covered": 8,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 14,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createInsertionOrdered",
+            "desc": "(Ljava/util/List;Ljava/util/List;)Ljava/util/Map;",
+            "line": 18,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.DataFetcherExceptionHandlerParameters$Builder": {
+        "line": {
+          "covered": 5,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "dataFetchingEnvironment",
+            "desc": "(Lgraphql/schema/DataFetchingEnvironment;)Lgraphql/execution/DataFetcherExceptionHandlerParameters$Builder;",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "exception",
+            "desc": "(Ljava/lang/Throwable;)Lgraphql/execution/DataFetcherExceptionHandlerParameters$Builder;",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/execution/DataFetcherExceptionHandlerParameters;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.InputMapDefinesTooManyFieldsException": {
+        "line": {
+          "covered": 3,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLType;Ljava/lang/String;)V",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocations",
+            "desc": "()Ljava/util/List;",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/ErrorType;",
+            "line": 35,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.ExecutionStepInfo$Builder": {
+        "line": {
+          "covered": 27,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 10,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 298,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/ExecutionStepInfo;)V",
+            "line": 302,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "type",
+            "desc": "(Lgraphql/schema/GraphQLOutputType;)Lgraphql/execution/ExecutionStepInfo$Builder;",
+            "line": 313,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parentInfo",
+            "desc": "(Lgraphql/execution/ExecutionStepInfo;)Lgraphql/execution/ExecutionStepInfo$Builder;",
+            "line": 318,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldDefinition",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;)Lgraphql/execution/ExecutionStepInfo$Builder;",
+            "line": 323,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "field",
+            "desc": "(Lgraphql/execution/MergedField;)Lgraphql/execution/ExecutionStepInfo$Builder;",
+            "line": 328,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "path",
+            "desc": "(Lgraphql/execution/ResultPath;)Lgraphql/execution/ExecutionStepInfo$Builder;",
+            "line": 333,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "arguments",
+            "desc": "(Ljava/util/function/Supplier;)Lgraphql/execution/ExecutionStepInfo$Builder;",
+            "line": 338,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldContainer",
+            "desc": "(Lgraphql/schema/GraphQLObjectType;)Lgraphql/execution/ExecutionStepInfo$Builder;",
+            "line": 343,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/execution/ExecutionStepInfo;",
+            "line": 348,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.Execution": {
+        "line": {
+          "covered": 140,
+          "missed": 13
+        },
+        "branch": {
+          "covered": 22,
+          "missed": 10
+        },
+        "method": {
+          "covered": 15,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/ExecutionStrategy;Lgraphql/execution/ExecutionStrategy;Lgraphql/execution/ExecutionStrategy;Lgraphql/execution/instrumentation/Instrumentation;Lgraphql/execution/ValueUnboxer;Z)V",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "execute",
+            "desc": "(Lgraphql/language/Document;Lgraphql/schema/GraphQLSchema;Lgraphql/execution/ExecutionId;Lgraphql/ExecutionInput;Lgraphql/execution/instrumentation/InstrumentationState;Lgraphql/EngineRunningState;Lgraphql/Profiler;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 90,
+            "counters": {
+              "line": {
+                "covered": 46,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "coerceVariableValues",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/ExecutionInput;Lgraphql/language/OperationDefinition;)Lgraphql/execution/CoercedVariables;",
+            "line": 155,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "normalizedVariableValues",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/ExecutionInput;Lgraphql/language/NodeUtil$GetOperationResult;)Ljava/util/function/Supplier;",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executeOperation",
+            "desc": "(Lgraphql/execution/ExecutionContext;Ljava/lang/Object;Lgraphql/language/OperationDefinition;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 176,
+            "counters": {
+              "line": {
+                "covered": 38,
+                "missed": 10
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "incrementalSupport",
+            "desc": "(Lgraphql/execution/ExecutionContext;Ljava/util/concurrent/CompletableFuture;)Ljava/util/concurrent/CompletableFuture;",
+            "line": 259,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "createDataLoaderDispatchStrategy",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/execution/ExecutionStrategy;)Lgraphql/execution/DataLoaderDispatchStrategy;",
+            "line": 287,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addExtensionsBuilderNotPresent",
+            "desc": "(Lgraphql/GraphQLContext;)V",
+            "line": 301,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mergeExtensionsBuilderIfPresent",
+            "desc": "(Lgraphql/ExecutionResult;Lgraphql/GraphQLContext;)Lgraphql/ExecutionResult;",
+            "line": 308,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "propagateErrorsOnNonNullContractFailure",
+            "desc": "(Ljava/util/List;)Z",
+            "line": 321,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$incrementalSupport$0",
+            "desc": "(Lgraphql/execution/ExecutionContext;Lgraphql/ExecutionResult;)Lgraphql/ExecutionResult;",
+            "line": 260,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$incrementalSupport$1",
+            "desc": "(Lgraphql/execution/instrumentation/InstrumentationContext;Ljava/lang/Throwable;)V",
+            "line": 272,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$executeOperation$0",
+            "desc": "(Lgraphql/GraphQLContext;Lgraphql/ExecutionResult;)Lgraphql/ExecutionResult;",
+            "line": 248,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$normalizedVariableValues$0",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Ljava/util/List;Lgraphql/execution/RawVariables;Lgraphql/ExecutionInput;)Lgraphql/execution/NormalizedVariables;",
+            "line": 166,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$execute$0",
+            "desc": "(Lgraphql/language/Document;Lgraphql/schema/GraphQLSchema;Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/util/Map;",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.ValuesResolver": {
+        "line": {
+          "covered": 126,
+          "missed": 5
+        },
+        "branch": {
+          "covered": 74,
+          "missed": 6
+        },
+        "method": {
+          "covered": 15,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "coerceVariableValues",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Ljava/util/List;Lgraphql/execution/RawVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)Lgraphql/execution/CoercedVariables;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNormalizedVariableValues",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Ljava/util/List;Lgraphql/execution/RawVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)Lgraphql/execution/NormalizedVariables;",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 18,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 13,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentValues",
+            "desc": "(Ljava/util/List;Ljava/util/List;Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/util/Map;",
+            "line": 157,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNormalizedArgumentValues",
+            "desc": "(Ljava/util/List;Ljava/util/List;Ljava/util/Map;)Ljava/util/Map;",
+            "line": 175,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentValues",
+            "desc": "(Lgraphql/schema/GraphQLCodeRegistry;Ljava/util/List;Ljava/util/List;Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/util/Map;",
+            "line": 209,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "valueToLiteral",
+            "desc": "(Lgraphql/schema/visibility/GraphqlFieldVisibility;Lgraphql/schema/InputValueWithState;Lgraphql/schema/GraphQLType;Lgraphql/GraphQLContext;Ljava/util/Locale;)Lgraphql/language/Value;",
+            "line": 233,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "valueToLiteral",
+            "desc": "(Lgraphql/schema/InputValueWithState;Lgraphql/schema/GraphQLType;Lgraphql/GraphQLContext;Ljava/util/Locale;)Lgraphql/language/Value;",
+            "line": 248,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "valueToInternalValue",
+            "desc": "(Lgraphql/schema/InputValueWithState;Lgraphql/schema/GraphQLInputType;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 263,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "externalValueToInternalValue",
+            "desc": "(Lgraphql/schema/visibility/GraphqlFieldVisibility;Ljava/lang/Object;Lgraphql/schema/GraphQLInputType;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 290,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInputValueImpl",
+            "desc": "(Lgraphql/schema/GraphQLInputType;Lgraphql/schema/InputValueWithState;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/lang/Object;",
+            "line": 309,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgumentValuesImpl",
+            "desc": "(Lgraphql/execution/values/InputInterceptor;Lgraphql/schema/visibility/GraphqlFieldVisibility;Ljava/util/List;Ljava/util/List;Lgraphql/execution/CoercedVariables;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/util/Map;",
+            "line": 330,
+            "counters": {
+              "line": {
+                "covered": 33,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 25,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "argumentMap",
+            "desc": "(Ljava/util/List;)Ljava/util/Map;",
+            "line": 388,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "literalToNormalizedValue",
+            "desc": "(Lgraphql/schema/visibility/GraphqlFieldVisibility;Lgraphql/schema/GraphQLType;Lgraphql/language/Value;Ljava/util/Map;)Ljava/lang/Object;",
+            "line": 401,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 12,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "literalToNormalizedValueForInputObject",
+            "desc": "(Lgraphql/schema/visibility/GraphqlFieldVisibility;Lgraphql/schema/GraphQLInputObjectType;Lgraphql/language/ObjectValue;Ljava/util/Map;)Ljava/lang/Object;",
+            "line": 443,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "literalToNormalizedValueForList",
+            "desc": "(Lgraphql/schema/visibility/GraphqlFieldVisibility;Lgraphql/schema/GraphQLList;Lgraphql/language/Value;Ljava/util/Map;)Ljava/util/List;",
+            "line": 466,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isVariableAbsent",
+            "desc": "(Lgraphql/language/Value;Ljava/util/Map;)Z",
+            "line": 492,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.FieldCollector": {
+        "line": {
+          "covered": 83,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 34,
+          "missed": 4
+        },
+        "method": {
+          "covered": 13,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "collectFields",
+            "desc": "(Lgraphql/execution/FieldCollectorParameters;Lgraphql/execution/MergedField;)Lgraphql/execution/MergedSelectionSet;",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "collectFields",
+            "desc": "(Lgraphql/execution/FieldCollectorParameters;Lgraphql/execution/MergedField;Z)Lgraphql/execution/MergedSelectionSet;",
+            "line": 42,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "collectFields",
+            "desc": "(Lgraphql/execution/FieldCollectorParameters;Lgraphql/language/SelectionSet;)Lgraphql/execution/MergedSelectionSet;",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "collectFields",
+            "desc": "(Lgraphql/execution/FieldCollectorParameters;Lgraphql/language/SelectionSet;Z)Lgraphql/execution/MergedSelectionSet;",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "collectFields",
+            "desc": "(Lgraphql/execution/FieldCollectorParameters;Lgraphql/language/SelectionSet;Ljava/util/Set;Ljava/util/Map;Lgraphql/execution/incremental/DeferredExecution;Z)V",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "collectFragmentSpread",
+            "desc": "(Lgraphql/execution/FieldCollectorParameters;Ljava/util/Set;Ljava/util/Map;Lgraphql/language/FragmentSpread;Z)V",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 20,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "collectInlineFragment",
+            "desc": "(Lgraphql/execution/FieldCollectorParameters;Ljava/util/Set;Ljava/util/Map;Lgraphql/language/InlineFragment;Z)V",
+            "line": 118,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "collectField",
+            "desc": "(Lgraphql/execution/FieldCollectorParameters;Ljava/util/Map;Lgraphql/language/Field;Lgraphql/execution/incremental/DeferredExecution;)V",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "doesFragmentConditionMatch",
+            "desc": "(Lgraphql/execution/FieldCollectorParameters;Lgraphql/language/InlineFragment;)Z",
+            "line": 152,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "doesFragmentConditionMatch",
+            "desc": "(Lgraphql/execution/FieldCollectorParameters;Lgraphql/language/FragmentDefinition;)Z",
+            "line": 162,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkTypeCondition",
+            "desc": "(Lgraphql/execution/FieldCollectorParameters;Lgraphql/schema/GraphQLType;)Z",
+            "line": 167,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$collectFields$0",
+            "desc": "(Lgraphql/execution/FieldCollectorParameters;Ljava/util/Set;Ljava/util/Map;ZLgraphql/language/Field;)V",
+            "line": 45,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.AbstractAsyncExecutionStrategy": {
+        "line": {
+          "covered": 10,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/DataFetcherExceptionHandler;)V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleResults",
+            "desc": "(Lgraphql/execution/ExecutionContext;Ljava/util/List;Ljava/util/concurrent/CompletableFuture;)Ljava/util/function/BiConsumer;",
+            "line": 24,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$handleResults$0",
+            "desc": "(Lgraphql/execution/ExecutionContext;Ljava/util/concurrent/CompletableFuture;Ljava/util/List;Ljava/util/List;Ljava/lang/Throwable;)V",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.DefaultValueUnboxer": {
+        "line": {
+          "covered": 21,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 14,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 18,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unbox",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 23,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "unboxValue",
+            "desc": "(Ljava/lang/Object;)Ljava/lang/Object;",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 19,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 14,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.ExecutionStrategyParameters$Builder": {
+        "line": {
+          "covered": 35,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 13,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 225,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/ExecutionStrategyParameters;)V",
+            "line": 225,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executionStepInfo",
+            "desc": "(Lgraphql/execution/ExecutionStepInfo;)Lgraphql/execution/ExecutionStrategyParameters$Builder;",
+            "line": 252,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executionStepInfo",
+            "desc": "(Lgraphql/execution/ExecutionStepInfo$Builder;)Lgraphql/execution/ExecutionStrategyParameters$Builder;",
+            "line": 257,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fields",
+            "desc": "(Lgraphql/execution/MergedSelectionSet;)Lgraphql/execution/ExecutionStrategyParameters$Builder;",
+            "line": 262,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "field",
+            "desc": "(Lgraphql/execution/MergedField;)Lgraphql/execution/ExecutionStrategyParameters$Builder;",
+            "line": 267,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "source",
+            "desc": "(Ljava/lang/Object;)Lgraphql/execution/ExecutionStrategyParameters$Builder;",
+            "line": 272,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "localContext",
+            "desc": "(Ljava/lang/Object;)Lgraphql/execution/ExecutionStrategyParameters$Builder;",
+            "line": 277,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "nonNullFieldValidator",
+            "desc": "(Lgraphql/execution/NonNullableFieldValidator;)Lgraphql/execution/ExecutionStrategyParameters$Builder;",
+            "line": 282,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "path",
+            "desc": "(Lgraphql/execution/ResultPath;)Lgraphql/execution/ExecutionStrategyParameters$Builder;",
+            "line": 287,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parent",
+            "desc": "(Lgraphql/execution/ExecutionStrategyParameters;)Lgraphql/execution/ExecutionStrategyParameters$Builder;",
+            "line": 292,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "deferredCallContext",
+            "desc": "(Lgraphql/execution/incremental/AlternativeCallContext;)Lgraphql/execution/ExecutionStrategyParameters$Builder;",
+            "line": 297,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/execution/ExecutionStrategyParameters;",
+            "line": 302,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.ExecutionStrategyParameters": {
+        "line": {
+          "covered": 29,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 2
+        },
+        "method": {
+          "covered": 17,
+          "missed": 3
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/ExecutionStepInfo;Ljava/lang/Object;Ljava/lang/Object;Lgraphql/execution/MergedSelectionSet;Lgraphql/execution/NonNullableFieldValidator;Lgraphql/execution/ResultPath;Lgraphql/execution/MergedField;Lgraphql/execution/ExecutionStrategyParameters;Lgraphql/execution/incremental/AlternativeCallContext;)V",
+            "line": 38,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExecutionStepInfo",
+            "desc": "()Lgraphql/execution/ExecutionStepInfo;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSource",
+            "desc": "()Ljava/lang/Object;",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFields",
+            "desc": "()Lgraphql/execution/MergedSelectionSet;",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNonNullFieldValidator",
+            "desc": "()Lgraphql/execution/NonNullableFieldValidator;",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPath",
+            "desc": "()Lgraphql/execution/ResultPath;",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocalContext",
+            "desc": "()Ljava/lang/Object;",
+            "line": 72,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParent",
+            "desc": "()Lgraphql/execution/ExecutionStrategyParameters;",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getDeferredCallContext",
+            "desc": "()Lgraphql/execution/incremental/AlternativeCallContext;",
+            "line": 102,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isInDeferredContext",
+            "desc": "()Z",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 2
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "getField",
+            "desc": "()Lgraphql/execution/MergedField;",
+            "line": 120,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Lgraphql/execution/MergedField;Lgraphql/execution/ResultPath;)Lgraphql/execution/ExecutionStrategyParameters;",
+            "line": 126,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Lgraphql/execution/ExecutionStepInfo;Lgraphql/execution/MergedSelectionSet;Ljava/lang/Object;)Lgraphql/execution/ExecutionStrategyParameters;",
+            "line": 141,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Lgraphql/execution/ExecutionStepInfo;Lgraphql/execution/ResultPath;Ljava/lang/Object;Ljava/lang/Object;)Lgraphql/execution/ExecutionStrategyParameters;",
+            "line": 157,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Lgraphql/execution/ExecutionStepInfo;Ljava/lang/Object;Ljava/lang/Object;)Lgraphql/execution/ExecutionStrategyParameters;",
+            "line": 172,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Lgraphql/execution/MergedField;Lgraphql/execution/ResultPath;Lgraphql/execution/ExecutionStrategyParameters;)Lgraphql/execution/ExecutionStrategyParameters;",
+            "line": 187,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "transform",
+            "desc": "(Ljava/util/function/Consumer;)Lgraphql/execution/ExecutionStrategyParameters;",
+            "line": 199,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 206,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "newParameters",
+            "desc": "()Lgraphql/execution/ExecutionStrategyParameters$Builder;",
+            "line": 211,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newParameters",
+            "desc": "(Lgraphql/execution/ExecutionStrategyParameters;)Lgraphql/execution/ExecutionStrategyParameters$Builder;",
+            "line": 215,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.ExecutionContextBuilder": {
+        "line": {
+          "covered": 97,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 33,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "newExecutionContextBuilder",
+            "desc": "()Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newExecutionContextBuilder",
+            "desc": "(Lgraphql/execution/ExecutionContext;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 77,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/ExecutionContext;)V",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 35,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "instrumentation",
+            "desc": "(Lgraphql/execution/instrumentation/Instrumentation;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 114,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "instrumentationState",
+            "desc": "(Lgraphql/execution/instrumentation/InstrumentationState;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 119,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executionId",
+            "desc": "(Lgraphql/execution/ExecutionId;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 124,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "graphQLSchema",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 129,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "queryStrategy",
+            "desc": "(Lgraphql/execution/ExecutionStrategy;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 134,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mutationStrategy",
+            "desc": "(Lgraphql/execution/ExecutionStrategy;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 139,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "subscriptionStrategy",
+            "desc": "(Lgraphql/execution/ExecutionStrategy;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 144,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "context",
+            "desc": "(Ljava/lang/Object;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "graphQLContext",
+            "desc": "(Lgraphql/GraphQLContext;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 158,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "localContext",
+            "desc": "(Ljava/lang/Object;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 163,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "root",
+            "desc": "(Ljava/lang/Object;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 168,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "variables",
+            "desc": "(Ljava/util/Map;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 181,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "coercedVariables",
+            "desc": "(Lgraphql/execution/CoercedVariables;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 186,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "normalizedVariableValues",
+            "desc": "(Ljava/util/function/Supplier;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 191,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fragmentsByName",
+            "desc": "(Ljava/util/Map;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 196,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "document",
+            "desc": "(Lgraphql/language/Document;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 201,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "operationDefinition",
+            "desc": "(Lgraphql/language/OperationDefinition;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 206,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "dataLoaderRegistry",
+            "desc": "(Lorg/dataloader/DataLoaderRegistry;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 211,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "locale",
+            "desc": "(Ljava/util/Locale;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 216,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "valueUnboxer",
+            "desc": "(Lgraphql/execution/ValueUnboxer;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 221,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "executionInput",
+            "desc": "(Lgraphql/ExecutionInput;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 226,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "dataLoaderDispatcherStrategy",
+            "desc": "(Lgraphql/execution/DataLoaderDispatchStrategy;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 232,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "responseMapFactory",
+            "desc": "(Lgraphql/execution/ResponseMapFactory;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 238,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "resetErrors",
+            "desc": "()Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 243,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "propagapropagateErrorsOnNonNullContractFailureeErrors",
+            "desc": "(Z)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 249,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "engineRunningState",
+            "desc": "(Lgraphql/EngineRunningState;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 254,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "profiler",
+            "desc": "(Lgraphql/Profiler;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 259,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "operationDirectives",
+            "desc": "(Ljava/util/function/Supplier;)Lgraphql/execution/ExecutionContextBuilder;",
+            "line": 264,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/execution/ExecutionContext;",
+            "line": 271,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.ValueUnboxer": {
+        "line": {
+          "covered": 1,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.ExecutionId": {
+        "line": {
+          "covered": 7,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "generate",
+            "desc": "()Lgraphql/execution/ExecutionId;",
+            "line": 21,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "from",
+            "desc": "(Ljava/lang/String;)Lgraphql/execution/ExecutionId;",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.execution.MergedField$Builder": {
+        "line": {
+          "covered": 37,
+          "missed": 10
+        },
+        "branch": {
+          "covered": 21,
+          "missed": 9
+        },
+        "method": {
+          "covered": 7,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/execution/MergedField;)V",
+            "line": 349,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 10
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 4
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "ensureDeferredExecutionsListBuilder",
+            "desc": "()Lcom/google/common/collect/ImmutableList$Builder;",
+            "line": 364,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ensureFieldsListBuilder",
+            "desc": "()Lcom/google/common/collect/ImmutableList$Builder;",
+            "line": 371,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fields",
+            "desc": "(Ljava/util/Collection;)Lgraphql/execution/MergedField$Builder;",
+            "line": 382,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addField",
+            "desc": "(Lgraphql/language/Field;)Lgraphql/execution/MergedField$Builder;",
+            "line": 394,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addDeferredExecutions",
+            "desc": "(Ljava/util/List;)Lgraphql/execution/MergedField$Builder;",
+            "line": 405,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addDeferredExecution",
+            "desc": "(Lgraphql/execution/incremental/DeferredExecution;)Lgraphql/execution/MergedField$Builder;",
+            "line": 414,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/execution/MergedField;",
+            "line": 423,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.validation.ValidationErrorCollector": {
+        "line": {
+          "covered": 21,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 7,
+          "missed": 5
+        },
+        "method": {
+          "covered": 7,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 18,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(I)V",
+            "line": 14,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "atMaxErrors",
+            "desc": "()Z",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addError",
+            "desc": "(Lgraphql/validation/ValidationError;)V",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrors",
+            "desc": "()Ljava/util/List;",
+            "line": 52,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "containsValidationError",
+            "desc": "(Lgraphql/validation/ValidationErrorType;)Z",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "containsValidationError",
+            "desc": "(Lgraphql/validation/ValidationErrorType;Ljava/lang/String;)Z",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 5
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.validation.ValidationError$Builder": {
+        "line": {
+          "covered": 14,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 1,
+          "missed": 1
+        },
+        "method": {
+          "covered": 8,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validationErrorType",
+            "desc": "(Lgraphql/validation/ValidationErrorClassification;)Lgraphql/validation/ValidationError$Builder;",
+            "line": 123,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "description",
+            "desc": "(Ljava/lang/String;)Lgraphql/validation/ValidationError$Builder;",
+            "line": 128,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "queryPath",
+            "desc": "(Ljava/util/List;)Lgraphql/validation/ValidationError$Builder;",
+            "line": 133,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocation",
+            "desc": "(Lgraphql/language/SourceLocation;)Lgraphql/validation/ValidationError$Builder;",
+            "line": 138,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sourceLocations",
+            "desc": "(Ljava/util/List;)Lgraphql/validation/ValidationError$Builder;",
+            "line": 143,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "extensions",
+            "desc": "(Ljava/util/Map;)Lgraphql/validation/ValidationError$Builder;",
+            "line": 148,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/validation/ValidationError;",
+            "line": 153,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.validation.VariablesTypesMatcher": {
+        "line": {
+          "covered": 19,
+          "missed": 4
+        },
+        "branch": {
+          "covered": 27,
+          "missed": 5
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "doesVariableTypesMatch",
+            "desc": "(Lgraphql/schema/GraphQLType;Lgraphql/language/Value;Lgraphql/schema/GraphQLType;Lgraphql/language/Value;)Z",
+            "line": 29,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 14,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "effectiveType",
+            "desc": "(Lgraphql/schema/GraphQLType;Lgraphql/language/Value;)Lgraphql/schema/GraphQLType;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 3
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkType",
+            "desc": "(Lgraphql/schema/GraphQLType;Lgraphql/schema/GraphQLType;)Z",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.validation.Validator": {
+        "line": {
+          "covered": 21,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 14,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "setMaxValidationErrors",
+            "desc": "(I)V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMaxValidationErrors",
+            "desc": "()I",
+            "line": 32,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "validateDocument",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/Document;Ljava/util/Locale;)Ljava/util/List;",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateDocument",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/Document;Ljava/util/function/Predicate;Ljava/util/Locale;)Ljava/util/List;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateDocument",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/Document;Ljava/util/function/Predicate;Ljava/util/Locale;Lgraphql/validation/QueryComplexityLimits;)Ljava/util/List;",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$validateDocument$0",
+            "desc": "(Lgraphql/validation/OperationValidationRule;)Z",
+            "line": 36,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 16,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.validation.ValidationContext": {
+        "line": {
+          "covered": 35,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 6,
+          "missed": 0
+        },
+        "method": {
+          "covered": 19,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/Document;Lgraphql/i18n/I18n;)V",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/language/Document;Lgraphql/i18n/I18n;Lgraphql/validation/QueryComplexityLimits;)V",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildFragmentMap",
+            "desc": "()V",
+            "line": 53,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getTraversalContext",
+            "desc": "()Lgraphql/validation/TraversalContext;",
+            "line": 63,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getSchema",
+            "desc": "()Lgraphql/schema/GraphQLSchema;",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDocument",
+            "desc": "()Lgraphql/language/Document;",
+            "line": 71,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFragment",
+            "desc": "(Ljava/lang/String;)Lgraphql/language/FragmentDefinition;",
+            "line": 75,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParentType",
+            "desc": "()Lgraphql/schema/GraphQLCompositeType;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInputType",
+            "desc": "()Lgraphql/schema/GraphQLInputType;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefaultValue",
+            "desc": "()Lgraphql/schema/InputValueWithState;",
+            "line": 87,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDef",
+            "desc": "()Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirective",
+            "desc": "()Lgraphql/schema/GraphQLDirective;",
+            "line": 95,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgument",
+            "desc": "()Lgraphql/schema/GraphQLArgument;",
+            "line": 99,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOutputType",
+            "desc": "()Lgraphql/schema/GraphQLOutputType;",
+            "line": 103,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getQueryPath",
+            "desc": "()Ljava/util/List;",
+            "line": 107,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getI18n",
+            "desc": "()Lgraphql/i18n/I18n;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getGraphQLContext",
+            "desc": "()Lgraphql/GraphQLContext;",
+            "line": 115,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getQueryComplexityLimits",
+            "desc": "()Lgraphql/validation/QueryComplexityLimits;",
+            "line": 119,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "i18n",
+            "desc": "(Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;",
+            "line": 131,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.validation.ValidationErrorCollector$MaxValidationErrorsReached": {
+        "line": {
+          "covered": 2,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 2,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fillInStackTrace",
+            "desc": "()Ljava/lang/Throwable;",
+            "line": 83,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.validation.LanguageTraversal": {
+        "line": {
+          "covered": 19,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 2
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 15,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/util/List;)V",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "traverse",
+            "desc": "(Lgraphql/language/Node;Lgraphql/validation/DocumentVisitor;)V",
+            "line": 28,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "traverseImpl",
+            "desc": "(Lgraphql/language/Node;Lgraphql/validation/DocumentVisitor;Ljava/util/List;)V",
+            "line": 33,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.validation.OperationValidator$Conflict": {
+        "line": {
+          "covered": 5,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Ljava/lang/String;Ljava/util/List;)V",
+            "line": 1487,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.validation.OperationValidator": {
+        "line": {
+          "covered": 960,
+          "missed": 20
+        },
+        "branch": {
+          "covered": 662,
+          "missed": 50
+        },
+        "method": {
+          "covered": 107,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/validation/ValidationContext;Lgraphql/validation/ValidationErrorCollector;Ljava/util/function/Predicate;)V",
+            "line": 282,
+            "counters": {
+              "line": {
+                "covered": 37,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "detectAllRulesEnabled",
+            "desc": "(Ljava/util/function/Predicate;)Z",
+            "line": 364,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isRuleEnabled",
+            "desc": "(Lgraphql/validation/OperationValidationRule;)Z",
+            "line": 373,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "shouldRunDocumentLevelRules",
+            "desc": "()Z",
+            "line": 389,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "shouldRunOperationScopedRules",
+            "desc": "()Z",
+            "line": 405,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkFieldCountLimit",
+            "desc": "()V",
+            "line": 411,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkDepthLimit",
+            "desc": "(I)V",
+            "line": 424,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enter",
+            "desc": "(Lgraphql/language/Node;Ljava/util/List;)V",
+            "line": 441,
+            "counters": {
+              "line": {
+                "covered": 35,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 32,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "leave",
+            "desc": "(Lgraphql/language/Node;Ljava/util/List;)V",
+            "line": 485,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 12,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addError",
+            "desc": "(Lgraphql/validation/ValidationErrorType;Ljava/util/Collection;Ljava/lang/String;)V",
+            "line": 503,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addError",
+            "desc": "(Lgraphql/validation/ValidationErrorType;Lgraphql/language/SourceLocation;Ljava/lang/String;)V",
+            "line": 517,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addError",
+            "desc": "(Lgraphql/validation/ValidationError$Builder;)V",
+            "line": 524,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getQueryPath",
+            "desc": "()Ljava/util/List;",
+            "line": 528,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "i18n",
+            "desc": "(Lgraphql/validation/ValidationErrorType;Lgraphql/i18n/I18nMsg;)Ljava/lang/String;",
+            "line": 532,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "i18n",
+            "desc": "(Lgraphql/validation/ValidationErrorType;Ljava/lang/String;[Ljava/lang/Object;)Ljava/lang/String;",
+            "line": 536,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkTypeAndPath",
+            "desc": "(Lgraphql/validation/ValidationErrorType;)Ljava/lang/String;",
+            "line": 543,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isExperimentalApiKeyEnabled",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 553,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkDocument",
+            "desc": "(Lgraphql/language/Document;)V",
+            "line": 558,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkArgument",
+            "desc": "(Lgraphql/language/Argument;)V",
+            "line": 564,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkTypeName",
+            "desc": "(Lgraphql/language/TypeName;)V",
+            "line": 575,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkVariableDefinition",
+            "desc": "(Lgraphql/language/VariableDefinition;)V",
+            "line": 583,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 11,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkField",
+            "desc": "(Lgraphql/language/Field;)V",
+            "line": 603,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 16,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkGoodFaithIntrospection",
+            "desc": "(Lgraphql/language/Field;)V",
+            "line": 628,
+            "counters": {
+              "line": {
+                "covered": 22,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 26,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkInlineFragment",
+            "desc": "(Lgraphql/language/InlineFragment;)V",
+            "line": 670,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkDirective",
+            "desc": "(Lgraphql/language/Directive;Ljava/util/List;)V",
+            "line": 684,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 16,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkFragmentSpread",
+            "desc": "(Lgraphql/language/FragmentSpread;Ljava/util/List;)V",
+            "line": 709,
+            "counters": {
+              "line": {
+                "covered": 36,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 26,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkFragmentDefinition",
+            "desc": "(Lgraphql/language/FragmentDefinition;)V",
+            "line": 773,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 12,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkOperationDefinition",
+            "desc": "(Lgraphql/language/OperationDefinition;)V",
+            "line": 795,
+            "counters": {
+              "line": {
+                "covered": 26,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 22,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkVariable",
+            "desc": "(Lgraphql/language/VariableReference;)V",
+            "line": 835,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkSelectionSet",
+            "desc": "()V",
+            "line": 850,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "checkObjectValue",
+            "desc": "(Lgraphql/language/ObjectValue;)V",
+            "line": 853,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "leaveOperationDefinition",
+            "desc": "()V",
+            "line": 862,
+            "counters": {
+              "line": {
+                "covered": 14,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "leaveSelectionSet",
+            "desc": "()V",
+            "line": 884,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "leaveFragmentDefinition",
+            "desc": "()V",
+            "line": 889,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "documentFinished",
+            "desc": "()V",
+            "line": 892,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateExecutableDefinitions",
+            "desc": "(Lgraphql/language/Document;)V",
+            "line": 902,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "nonExecutableDefinitionMessage",
+            "desc": "(Lgraphql/language/Definition;)Ljava/lang/String;",
+            "line": 912,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateArgumentsOfCorrectType",
+            "desc": "(Lgraphql/language/Argument;)V",
+            "line": 924,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateFieldsOnCorrectType",
+            "desc": "(Lgraphql/language/Field;)V",
+            "line": 942,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateFragmentsOnCompositeType_inline",
+            "desc": "(Lgraphql/language/InlineFragment;)V",
+            "line": 955,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateFragmentsOnCompositeType_definition",
+            "desc": "(Lgraphql/language/FragmentDefinition;)V",
+            "line": 969,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateKnownArgumentNames",
+            "desc": "(Lgraphql/language/Argument;)V",
+            "line": 981,
+            "counters": {
+              "line": {
+                "covered": 15,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateKnownDirectives",
+            "desc": "(Lgraphql/language/Directive;Ljava/util/List;)V",
+            "line": 1003,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "hasInvalidLocation",
+            "desc": "(Lgraphql/schema/GraphQLDirective;Lgraphql/language/Node;)Z",
+            "line": 1017,
+            "counters": {
+              "line": {
+                "covered": 19,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 30,
+                "missed": 4
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateKnownFragmentNames",
+            "desc": "(Lgraphql/language/FragmentSpread;)V",
+            "line": 1043,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateKnownTypeNames",
+            "desc": "(Lgraphql/language/TypeName;)V",
+            "line": 1052,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "prepareFragmentSpreadsMap",
+            "desc": "()V",
+            "line": 1060,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "gatherSpreads",
+            "desc": "(Lgraphql/language/FragmentDefinition;)Ljava/util/Set;",
+            "line": 1070,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateNoFragmentCycles",
+            "desc": "(Lgraphql/language/FragmentDefinition;)V",
+            "line": 1088,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "buildTransitiveSpreads",
+            "desc": "(Ljava/util/ArrayList;Ljava/util/Map;)Ljava/util/Map;",
+            "line": 1101,
+            "counters": {
+              "line": {
+                "covered": 20,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 15,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateNoUndefinedVariables",
+            "desc": "(Lgraphql/language/VariableReference;)V",
+            "line": 1130,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateNoUnusedFragments",
+            "desc": "()V",
+            "line": 1138,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "collectUsedFragmentsInDefinition",
+            "desc": "(Ljava/util/Set;Ljava/lang/String;)V",
+            "line": 1153,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateOverlappingFieldsCanBeMerged",
+            "desc": "(Lgraphql/language/OperationDefinition;)V",
+            "line": 1167,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "overlappingFieldsImpl",
+            "desc": "(Lgraphql/language/SelectionSet;Lgraphql/schema/GraphQLOutputType;)V",
+            "line": 1171,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "overlappingFields_collectFields",
+            "desc": "(Ljava/util/Map;Lgraphql/language/SelectionSet;Lgraphql/schema/GraphQLType;Ljava/util/Set;)V",
+            "line": 1185,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "overlappingFields_collectFieldsForFragmentSpread",
+            "desc": "(Ljava/util/Map;Ljava/util/Set;Lgraphql/language/FragmentSpread;)V",
+            "line": 1197,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "overlappingFields_collectFieldsForInlineFragment",
+            "desc": "(Ljava/util/Map;Ljava/util/Set;Lgraphql/schema/GraphQLType;Lgraphql/language/InlineFragment;)V",
+            "line": 1211,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "overlappingFields_collectFieldsForField",
+            "desc": "(Ljava/util/Map;Lgraphql/schema/GraphQLType;Lgraphql/language/Field;)V",
+            "line": 1220,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "findConflicts",
+            "desc": "(Ljava/util/Map;)Ljava/util/List;",
+            "line": 1232,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sameResponseShapeByName",
+            "desc": "(Ljava/util/Map;Lcom/google/common/collect/ImmutableList;Ljava/util/List;)V",
+            "line": 1239,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mergeSubSelections",
+            "desc": "(Ljava/util/Set;)Ljava/util/Map;",
+            "line": 1256,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sameForCommonParentsByName",
+            "desc": "(Ljava/util/Map;Lcom/google/common/collect/ImmutableList;Ljava/util/List;)V",
+            "line": 1267,
+            "counters": {
+              "line": {
+                "covered": 16,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "groupByCommonParents",
+            "desc": "(Ljava/util/Set;)Ljava/util/List;",
+            "line": 1288,
+            "counters": {
+              "line": {
+                "covered": 23,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 19,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isInterfaceOrUnion",
+            "desc": "(Lgraphql/schema/GraphQLType;)Z",
+            "line": 1324,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "requireSameNameAndArguments",
+            "desc": "(Lcom/google/common/collect/ImmutableList;Ljava/util/Set;)Lgraphql/validation/OperationValidator$Conflict;",
+            "line": 1328,
+            "counters": {
+              "line": {
+                "covered": 20,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "pathToString",
+            "desc": "(Lcom/google/common/collect/ImmutableList;)Ljava/lang/String;",
+            "line": 1355,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "sameArguments",
+            "desc": "(Ljava/util/List;Ljava/util/List;)Z",
+            "line": 1359,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "findArgumentByName",
+            "desc": "(Ljava/lang/String;Ljava/util/List;)Lgraphql/language/Argument;",
+            "line": 1375,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "requireSameOutputTypeShape",
+            "desc": "(Lcom/google/common/collect/ImmutableList;Ljava/util/Set;)Lgraphql/validation/OperationValidator$Conflict;",
+            "line": 1384,
+            "counters": {
+              "line": {
+                "covered": 32,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 35,
+                "missed": 7
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "mkNotSameTypeError",
+            "desc": "(Lcom/google/common/collect/ImmutableList;Ljava/util/List;Lgraphql/schema/GraphQLType;Lgraphql/schema/GraphQLType;)Lgraphql/validation/OperationValidator$Conflict;",
+            "line": 1434,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "notSameType",
+            "desc": "(Lgraphql/schema/GraphQLType;Lgraphql/schema/GraphQLType;)Z",
+            "line": 1441,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validatePossibleFragmentSpreads_inline",
+            "desc": "(Lgraphql/language/InlineFragment;)V",
+            "line": 1497,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validatePossibleFragmentSpreads_spread",
+            "desc": "(Lgraphql/language/FragmentSpread;)V",
+            "line": 1510,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "typesDoNotOverlap",
+            "desc": "(Lgraphql/schema/GraphQLType;Lgraphql/schema/GraphQLCompositeType;)Z",
+            "line": 1527,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getPossibleType",
+            "desc": "(Lgraphql/schema/GraphQLType;)Ljava/util/List;",
+            "line": 1536,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 2
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isValidTargetCompositeType",
+            "desc": "(Lgraphql/schema/GraphQLType;)Z",
+            "line": 1550,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateProvidedNonNullArguments_field",
+            "desc": "(Lgraphql/language/Field;)V",
+            "line": 1555,
+            "counters": {
+              "line": {
+                "covered": 18,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 18,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateProvidedNonNullArguments_directive",
+            "desc": "(Lgraphql/language/Directive;)V",
+            "line": 1580,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "findArgumentByName",
+            "desc": "(Ljava/util/List;Ljava/lang/String;)Lgraphql/language/Argument;",
+            "line": 1598,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateScalarLeaves",
+            "desc": "(Lgraphql/language/Field;)V",
+            "line": 1608,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateVariableDefaultValuesOfCorrectType",
+            "desc": "(Lgraphql/language/VariableDefinition;)V",
+            "line": 1627,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateVariablesAreInputTypes",
+            "desc": "(Lgraphql/language/VariableDefinition;)V",
+            "line": 1641,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateVariableTypesMatch",
+            "desc": "(Lgraphql/language/VariableReference;)V",
+            "line": 1654,
+            "counters": {
+              "line": {
+                "covered": 23,
+                "missed": 4
+              },
+              "branch": {
+                "covered": 15,
+                "missed": 3
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateLoneAnonymousOperation",
+            "desc": "(Lgraphql/language/OperationDefinition;)V",
+            "line": 1690,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateUniqueOperationNames",
+            "desc": "(Lgraphql/language/OperationDefinition;)V",
+            "line": 1708,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateUniqueFragmentNames",
+            "desc": "(Lgraphql/language/FragmentDefinition;)V",
+            "line": 1722,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 3,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateUniqueDirectiveNamesPerLocation",
+            "desc": "(Lgraphql/language/Node;Ljava/util/List;)V",
+            "line": 1736,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 10,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateUniqueArgumentNames_field",
+            "desc": "(Lgraphql/language/Field;)V",
+            "line": 1752,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateUniqueArgumentNames_directive",
+            "desc": "(Lgraphql/language/Directive;)V",
+            "line": 1756,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateUniqueArgumentNames",
+            "desc": "(Ljava/util/List;Lgraphql/language/SourceLocation;)V",
+            "line": 1760,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateUniqueVariableNames",
+            "desc": "(Lgraphql/language/OperationDefinition;)V",
+            "line": 1776,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateSubscriptionUniqueRootField",
+            "desc": "(Lgraphql/language/OperationDefinition;)V",
+            "line": 1793,
+            "counters": {
+              "line": {
+                "covered": 19,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isIntrospectionField",
+            "desc": "(Lgraphql/execution/MergedField;)Z",
+            "line": 1817,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateUniqueObjectFieldName",
+            "desc": "(Lgraphql/language/ObjectValue;)V",
+            "line": 1822,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateDeferDirectiveOnRootLevel",
+            "desc": "(Lgraphql/language/Directive;)V",
+            "line": 1836,
+            "counters": {
+              "line": {
+                "covered": 13,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 11,
+                "missed": 5
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateDeferDirectiveOnValidOperation",
+            "desc": "(Lgraphql/language/Directive;Ljava/util/List;)V",
+            "line": 1856,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOperationDefinition",
+            "desc": "(Ljava/util/List;)Ljava/util/Optional;",
+            "line": 1872,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "ifArgumentMightBeFalse",
+            "desc": "(Lgraphql/language/Directive;)Z",
+            "line": 1879,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateDeferDirectiveLabel",
+            "desc": "(Lgraphql/language/Directive;)V",
+            "line": 1891,
+            "counters": {
+              "line": {
+                "covered": 19,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 14,
+                "missed": 4
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "validateKnownOperationTypes",
+            "desc": "(Lgraphql/language/OperationDefinition;)V",
+            "line": 1917,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "formatOperation",
+            "desc": "(Lgraphql/language/OperationDefinition$Operation;)Ljava/lang/String;",
+            "line": 1931,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 1936,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "lambda$getOperationDefinition$1",
+            "desc": "(Lgraphql/language/Node;)Lgraphql/language/OperationDefinition;",
+            "line": 1874,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getOperationDefinition$0",
+            "desc": "(Lgraphql/language/Node;)Z",
+            "line": 1873,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$groupByCommonParents$0",
+            "desc": "(Lgraphql/schema/GraphQLType;)Ljava/util/Set;",
+            "line": 1301,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$overlappingFields_collectFieldsForField$0",
+            "desc": "(Ljava/lang/String;)Ljava/util/Set;",
+            "line": 1228,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$validateExecutableDefinitions$0",
+            "desc": "(Lgraphql/language/Definition;)V",
+            "line": 903,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.validation.ArgumentValidationUtil": {
+        "line": {
+          "covered": 48,
+          "missed": 2
+        },
+        "branch": {
+          "covered": 6,
+          "missed": 2
+        },
+        "method": {
+          "covered": 12,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Argument;)V",
+            "line": 22,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleNullError",
+            "desc": "(Lgraphql/language/Value;Lgraphql/schema/GraphQLType;)V",
+            "line": 37,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleScalarError",
+            "desc": "(Lgraphql/language/Value;Lgraphql/schema/GraphQLScalarType;Lgraphql/GraphQLError;)V",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleEnumError",
+            "desc": "(Lgraphql/language/Value;Lgraphql/schema/GraphQLEnumType;Lgraphql/GraphQLError;)V",
+            "line": 56,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleNotObjectError",
+            "desc": "(Lgraphql/language/Value;Lgraphql/schema/GraphQLInputObjectType;)V",
+            "line": 68,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleMissingFieldsError",
+            "desc": "(Lgraphql/language/Value;Lgraphql/schema/GraphQLInputObjectType;Ljava/util/Set;)V",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleExtraFieldError",
+            "desc": "(Lgraphql/language/Value;Lgraphql/schema/GraphQLInputObjectType;Lgraphql/language/ObjectField;)V",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleFieldNotValidError",
+            "desc": "(Lgraphql/language/ObjectField;Lgraphql/schema/GraphQLInputObjectType;)V",
+            "line": 86,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleFieldNotValidError",
+            "desc": "(Lgraphql/language/Value;Lgraphql/schema/GraphQLType;I)V",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleExtraOneOfFieldsError",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;Lgraphql/language/Value;)V",
+            "line": 96,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMsgAndArgs",
+            "desc": "()Lgraphql/i18n/I18nMsg;",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrorExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.validation.ValidationError": {
+        "line": {
+          "covered": 27,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 8,
+          "missed": 0
+        },
+        "method": {
+          "covered": 11,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/validation/ValidationError$Builder;)V",
+            "line": 25,
+            "counters": {
+              "line": {
+                "covered": 11,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getValidationErrorType",
+            "desc": "()Lgraphql/validation/ValidationErrorClassification;",
+            "line": 46,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMessage",
+            "desc": "()Ljava/lang/String;",
+            "line": 51,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDescription",
+            "desc": "()Ljava/lang/String;",
+            "line": 55,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLocations",
+            "desc": "()Ljava/util/List;",
+            "line": 60,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/ErrorType;",
+            "line": 65,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getQueryPath",
+            "desc": "()Ljava/util/List;",
+            "line": 69,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getExtensions",
+            "desc": "()Ljava/util/Map;",
+            "line": 74,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newValidationError",
+            "desc": "()Lgraphql/validation/ValidationError$Builder;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$toString$0",
+            "desc": "(Ljava/lang/String;)Ljava/lang/String;",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.validation.GoodFaithIntrospectionExceeded": {
+        "line": {
+          "covered": 10,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(ZLjava/lang/String;)V",
+            "line": 20,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "tooManyFields",
+            "desc": "(Ljava/lang/String;)Lgraphql/validation/GoodFaithIntrospectionExceeded;",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "tooBigOperation",
+            "desc": "(Ljava/lang/String;)Lgraphql/validation/GoodFaithIntrospectionExceeded;",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toBadFaithError",
+            "desc": "()Lgraphql/introspection/GoodFaithIntrospection$BadFaithIntrospectionError;",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fillInStackTrace",
+            "desc": "()Ljava/lang/Throwable;",
+            "line": 43,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.validation.OperationValidationRule": {
+        "line": {
+          "covered": 33,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 33,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.validation.OperationValidator$1": {
+        "line": {
+          "covered": 5,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 2,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/validation/OperationValidator;Ljava/util/Set;)V",
+            "line": 1071,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enter",
+            "desc": "(Lgraphql/language/Node;Ljava/util/List;)V",
+            "line": 1074,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "leave",
+            "desc": "(Lgraphql/language/Node;Ljava/util/List;)V",
+            "line": 1081,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.validation.QueryComplexityLimits": {
+        "line": {
+          "covered": 13,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 7,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "setDefaultLimits",
+            "desc": "(Lgraphql/validation/QueryComplexityLimits;)V",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefaultLimits",
+            "desc": "()Lgraphql/validation/QueryComplexityLimits;",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(II)V",
+            "line": 88,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMaxDepth",
+            "desc": "()I",
+            "line": 97,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMaxFieldsCount",
+            "desc": "()I",
+            "line": 104,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "newLimits",
+            "desc": "()Lgraphql/validation/QueryComplexityLimits$Builder;",
+            "line": 111,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 57,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.validation.ValidationUtil": {
+        "line": {
+          "covered": 85,
+          "missed": 3
+        },
+        "branch": {
+          "covered": 52,
+          "missed": 2
+        },
+        "method": {
+          "covered": 20,
+          "missed": 2
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 44,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getUnmodifiedType",
+            "desc": "(Lgraphql/language/Type;)Lgraphql/language/TypeName;",
+            "line": 47,
+            "counters": {
+              "line": {
+                "covered": 6,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleNullError",
+            "desc": "(Lgraphql/language/Value;Lgraphql/schema/GraphQLType;)V",
+            "line": 58,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleScalarError",
+            "desc": "(Lgraphql/language/Value;Lgraphql/schema/GraphQLScalarType;Lgraphql/GraphQLError;)V",
+            "line": 61,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleEnumError",
+            "desc": "(Lgraphql/language/Value;Lgraphql/schema/GraphQLEnumType;Lgraphql/GraphQLError;)V",
+            "line": 64,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleNotObjectError",
+            "desc": "(Lgraphql/language/Value;Lgraphql/schema/GraphQLInputObjectType;)V",
+            "line": 67,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "handleMissingFieldsError",
+            "desc": "(Lgraphql/language/Value;Lgraphql/schema/GraphQLInputObjectType;Ljava/util/Set;)V",
+            "line": 70,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleExtraFieldError",
+            "desc": "(Lgraphql/language/Value;Lgraphql/schema/GraphQLInputObjectType;Lgraphql/language/ObjectField;)V",
+            "line": 73,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          },
+          {
+            "name": "handleFieldNotValidError",
+            "desc": "(Lgraphql/language/ObjectField;Lgraphql/schema/GraphQLInputObjectType;)V",
+            "line": 76,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleFieldNotValidError",
+            "desc": "(Lgraphql/language/Value;Lgraphql/schema/GraphQLType;I)V",
+            "line": 79,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "handleExtraOneOfFieldsError",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;Lgraphql/language/Value;)V",
+            "line": 82,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isValidLiteralValue",
+            "desc": "(Lgraphql/language/Value;Lgraphql/schema/GraphQLType;Lgraphql/schema/GraphQLSchema;Lgraphql/GraphQLContext;Ljava/util/Locale;)Z",
+            "line": 85,
+            "counters": {
+              "line": {
+                "covered": 20,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 21,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseLiteralEnum",
+            "desc": "(Lgraphql/language/Value;Lgraphql/schema/GraphQLEnumType;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/util/Optional;",
+            "line": 119,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "parseLiteral",
+            "desc": "(Lgraphql/language/Value;Lgraphql/schema/Coercing;Lgraphql/GraphQLContext;Ljava/util/Locale;)Ljava/util/Optional;",
+            "line": 128,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isValidLiteralValueForInputObjectType",
+            "desc": "(Lgraphql/language/Value;Lgraphql/schema/GraphQLInputObjectType;Lgraphql/schema/GraphQLSchema;Lgraphql/GraphQLContext;Ljava/util/Locale;)Z",
+            "line": 136,
+            "counters": {
+              "line": {
+                "covered": 24,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 14,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMissingFields",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectType;Ljava/util/Map;Lgraphql/schema/visibility/GraphqlFieldVisibility;)Ljava/util/Set;",
+            "line": 174,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fieldMap",
+            "desc": "(Lgraphql/language/ObjectValue;)Ljava/util/Map;",
+            "line": 182,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isValidLiteralValue",
+            "desc": "(Lgraphql/language/Value;Lgraphql/schema/GraphQLList;Lgraphql/schema/GraphQLSchema;Lgraphql/GraphQLContext;Ljava/util/Locale;)Z",
+            "line": 190,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 6,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getMissingFields$1",
+            "desc": "(Ljava/util/Map;Lgraphql/schema/GraphQLInputObjectField;)Z",
+            "line": 176,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$getMissingFields$0",
+            "desc": "(Lgraphql/schema/GraphQLInputObjectField;)Z",
+            "line": 175,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isValidLiteralValue$1",
+            "desc": "(Lgraphql/language/Value;Lgraphql/schema/GraphQLType;Lgraphql/GraphQLError;)V",
+            "line": 106,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lambda$isValidLiteralValue$0",
+            "desc": "(Lgraphql/language/Value;Lgraphql/schema/GraphQLType;Lgraphql/GraphQLError;)V",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.validation.QueryComplexityLimits$Builder": {
+        "line": {
+          "covered": 13,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 4,
+          "missed": 0
+        },
+        "method": {
+          "covered": 4,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "()V",
+            "line": 128,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "maxDepth",
+            "desc": "(I)Lgraphql/validation/QueryComplexityLimits$Builder;",
+            "line": 142,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "maxFieldsCount",
+            "desc": "(I)Lgraphql/validation/QueryComplexityLimits$Builder;",
+            "line": 157,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "build",
+            "desc": "()Lgraphql/validation/QueryComplexityLimits;",
+            "line": 168,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.validation.QueryComplexityLimitsExceeded": {
+        "line": {
+          "covered": 9,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 5,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/validation/ValidationErrorType;II)V",
+            "line": 19,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getErrorType",
+            "desc": "()Lgraphql/validation/ValidationErrorType;",
+            "line": 26,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getLimit",
+            "desc": "()I",
+            "line": 30,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getActual",
+            "desc": "()I",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "fillInStackTrace",
+            "desc": "()Ljava/lang/Throwable;",
+            "line": 40,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.validation.FragmentComplexityInfo": {
+        "line": {
+          "covered": 6,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 3,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(II)V",
+            "line": 18,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldCount",
+            "desc": "()I",
+            "line": 27,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getMaxDepth",
+            "desc": "()I",
+            "line": 34,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 39,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.validation.ValidationErrorType": {
+        "line": {
+          "covered": 42,
+          "missed": 0
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;clinit&gt;",
+            "desc": "()V",
+            "line": 7,
+            "counters": {
+              "line": {
+                "covered": 42,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      },
+      "graphql.validation.OperationValidator$FieldAndType": {
+        "line": {
+          "covered": 5,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 0,
+          "missed": 0
+        },
+        "method": {
+          "covered": 1,
+          "missed": 1
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/language/Field;Lgraphql/schema/GraphQLType;Lgraphql/schema/GraphQLType;)V",
+            "line": 1452,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "toString",
+            "desc": "()Ljava/lang/String;",
+            "line": 1460,
+            "counters": {
+              "line": {
+                "covered": 0,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 0,
+                "missed": 1
+              }
+            }
+          }
+        ]
+      },
+      "graphql.validation.TraversalContext": {
+        "line": {
+          "covered": 176,
+          "missed": 1
+        },
+        "branch": {
+          "covered": 111,
+          "missed": 7
+        },
+        "method": {
+          "covered": 34,
+          "missed": 0
+        },
+        "methods": [
+          {
+            "name": "&lt;init&gt;",
+            "desc": "(Lgraphql/schema/GraphQLSchema;)V",
+            "line": 50,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enter",
+            "desc": "(Lgraphql/language/Node;Ljava/util/List;)V",
+            "line": 66,
+            "counters": {
+              "line": {
+                "covered": 21,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 20,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enterImpl",
+            "desc": "(Lgraphql/language/SelectionSet;)V",
+            "line": 91,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enterImpl",
+            "desc": "(Lgraphql/language/Field;)V",
+            "line": 101,
+            "counters": {
+              "line": {
+                "covered": 8,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enterImpl",
+            "desc": "(Lgraphql/language/Directive;)V",
+            "line": 112,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enterImpl",
+            "desc": "(Lgraphql/language/OperationDefinition;)V",
+            "line": 116,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 1
+              },
+              "branch": {
+                "covered": 5,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enterImpl",
+            "desc": "(Lgraphql/language/InlineFragment;)V",
+            "line": 128,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enterImpl",
+            "desc": "(Lgraphql/language/FragmentDefinition;)V",
+            "line": 144,
+            "counters": {
+              "line": {
+                "covered": 4,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enterImpl",
+            "desc": "(Lgraphql/language/VariableDefinition;)V",
+            "line": 150,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enterImpl",
+            "desc": "(Lgraphql/language/Argument;)V",
+            "line": 155,
+            "counters": {
+              "line": {
+                "covered": 9,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 8,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enterImpl",
+            "desc": "(Lgraphql/language/ArrayValue;)V",
+            "line": 168,
+            "counters": {
+              "line": {
+                "covered": 7,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enterImpl",
+            "desc": "(Lgraphql/language/ObjectField;)V",
+            "line": 179,
+            "counters": {
+              "line": {
+                "covered": 12,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 7,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "find",
+            "desc": "(Ljava/util/List;Ljava/lang/String;)Lgraphql/schema/GraphQLArgument;",
+            "line": 195,
+            "counters": {
+              "line": {
+                "covered": 5,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "leave",
+            "desc": "(Lgraphql/language/Node;Ljava/util/List;)V",
+            "line": 206,
+            "counters": {
+              "line": {
+                "covered": 28,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 20,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "enterName",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 237,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "leaveName",
+            "desc": "(Ljava/lang/String;)V",
+            "line": 243,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 1,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "isEmpty",
+            "desc": "(Ljava/lang/String;)Z",
+            "line": 249,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 2
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getNullableType",
+            "desc": "(Lgraphql/schema/GraphQLType;)Lgraphql/schema/GraphQLNullableType;",
+            "line": 253,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 4,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getOutputType",
+            "desc": "()Lgraphql/schema/GraphQLOutputType;",
+            "line": 264,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addOutputType",
+            "desc": "(Lgraphql/schema/GraphQLOutputType;)V",
+            "line": 268,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "lastElement",
+            "desc": "(Ljava/util/List;)Ljava/lang/Object;",
+            "line": 272,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "pop",
+            "desc": "(Ljava/util/List;)Ljava/lang/Object;",
+            "line": 279,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getParentType",
+            "desc": "()Lgraphql/schema/GraphQLCompositeType;",
+            "line": 286,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addParentType",
+            "desc": "(Lgraphql/schema/GraphQLCompositeType;)V",
+            "line": 290,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getInputType",
+            "desc": "()Lgraphql/schema/GraphQLInputType;",
+            "line": 294,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDefaultValue",
+            "desc": "()Lgraphql/schema/InputValueWithState;",
+            "line": 298,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addInputType",
+            "desc": "(Lgraphql/schema/GraphQLInputType;)V",
+            "line": 302,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addDefaultValue",
+            "desc": "(Lgraphql/schema/InputValueWithState;)V",
+            "line": 306,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDef",
+            "desc": "()Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 310,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getQueryPath",
+            "desc": "()Ljava/util/List;",
+            "line": 314,
+            "counters": {
+              "line": {
+                "covered": 3,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 2,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "addFieldDef",
+            "desc": "(Lgraphql/schema/GraphQLFieldDefinition;)V",
+            "line": 321,
+            "counters": {
+              "line": {
+                "covered": 2,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getDirective",
+            "desc": "()Lgraphql/schema/GraphQLDirective;",
+            "line": 325,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getArgument",
+            "desc": "()Lgraphql/schema/GraphQLArgument;",
+            "line": 329,
+            "counters": {
+              "line": {
+                "covered": 1,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 0,
+                "missed": 0
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          },
+          {
+            "name": "getFieldDef",
+            "desc": "(Lgraphql/schema/GraphQLSchema;Lgraphql/schema/GraphQLType;Lgraphql/language/Field;)Lgraphql/schema/GraphQLFieldDefinition;",
+            "line": 333,
+            "counters": {
+              "line": {
+                "covered": 10,
+                "missed": 0
+              },
+              "branch": {
+                "covered": 15,
+                "missed": 1
+              },
+              "method": {
+                "covered": 1,
+                "missed": 0
+              }
+            }
+          }
+        ]
+      }
+    }
+  }
+}