Function checkParseStringGate

json_fuzz_test.go:1159–1205

checkParseStringGate (Gate 8: PARSESTRING) extracts a String-typed value via Get and calls ParseString on the raw escaped content. Closes the API- coverage blind spot: without this gate, the structure-aware fuzzer NEVER reaches ParseString on grammar-generated escape sequences (\uXXXX, \uD800\uDC00

(t *testing.T, data []byte, path []string)

// surrogate pairs, \u0000, long escape runs). It also cross-checks the
// unescaped result against encoding/json on the same token.
func checkParseStringGate(t *testing.T, data []byte, path []string) {
	t.Helper()
	if len(data) > fuzzGateSizeCap {
		return
	}
	val, dt, _, err := Get(data, path...)
	if err != nil || dt != String || len(val) == 0 {
		return
	}
	out, perr := ParseString(val)
	if perr != nil {
		// ParseString rejects malformed escapes; that is a clean failure.
		return
	}
	// NOTE: jsonparser is documented as lenient on raw invalid UTF-8 bytes
	// inside strings — it passes them through unchanged (consistent with
	// Get's no-validate contract on these seeds). We therefore do NOT assert
	// utf8.ValidString(out); that would assert a contract the parser does
	// not claim to uphold. The differential check below is the honest gate:
	// for any token encoding/json accepts, ParseString MUST produce the same
	// output. Disagreement there is a genuine unescape bug.
	//
	// Cross-check against encoding/json's reference unescaper. Wrap val back
	// into a JSON string literal so json.Unmarshal sees the same token.
	// Restricted to valid-UTF-8 inputs because the two implementations
	// DOCUMENTEDLY disagree on invalid-UTF-8 handling (jsonparser passes
	// raw bytes through; encoding/json substitutes U+FFFD) — that is a
	// design choice, not an unescape bug.
	quoted := make([]byte, 0, len(val)+2)
	quoted = append(quoted, '"')
	quoted = append(quoted, val...)
	quoted = append(quoted, '"')
	var ref string
	if jerr := json.Unmarshal(quoted, &ref); jerr == nil && utf8.Valid(val) {
		// Both succeeded — they must agree byte-for-byte.
		if out != ref {
			t.Errorf("ParseString disagrees with encoding/json "+
				"(PARSESTRING differential): ParseString(%q)=%q json.Unmarshal=%q data=%q path=%v",
				val, out, ref, data, path)
		}
	}
	// Sanity: result is bounded (catches runaway allocation in Unescape).
	if len(out) > len(val)*4+16 {
		t.Errorf("ParseString returned suspiciously large output (PARSESTRING sanity): "+
			"in=%d out=%d data=%q path=%v", len(val), len(out), data, path)
	}
}

// checkParseBooleanGate (Gate 9: PARSEBOOLEAN) cross-checks ParseBoolean
// against strconv.ParseBool on Boolean-typed values. Closes the API-coverage