Function TestDoSPerformance

json_fuzz_test.go:1644–1683

TestDoSPerformance is a non-fuzz regression gate that asserts the parser completes each major operation on a 1MB input within dosOpBudget. Catches O(n²) regressions in tokenEnd/blockEnd/searchKeys that pure correctness fuzzing leaves invisible (a slow-but-correct parser is still a DoS bug). Verifie

(t *testing.T)

//
// Verifies: SYS-REQ-035 (no pathological-input hang).
func TestDoSPerformance(t *testing.T) {
	if testing.Short() {
		t.Skip("skipping DoS performance gate in -short mode")
	}
	// Build a ~1MB JSON document: deeply nested then a long string at the end.
	// Two pathological shapes are tested:
	//   (1) Deeply nested unclosed arrays — exercises the parser's descent
	//       cost when no closers exist.
	//   (2) Wide flat object with a 1MB string value — exercises the
	//       per-byte scanning cost in stringEnd.
	const targetBytes = 1 << 20 // 1 MiB

	t.Run("deep_nested", func(t *testing.T) {
		// 100k unclosed '[' — about 100KB; loop it to 1MB if needed.
		depth := 100_000
		for depth*2 < targetBytes {
			depth *= 2
		}
		data := genDeepNesting(depth, false)
		runDoSCase(t, "Get", data, func() { _, _, _, _ = Get(data) })
		runDoSCase(t, "ArrayEach", data, func() {
			_, _ = ArrayEach(data, func([]byte, ValueType, int, error) {})
		})
	})

	t.Run("long_string", func(t *testing.T) {
		// {"a":"<repeat x 1MB>"} — exercises stringEnd on a long token.
		body := bytes.Repeat([]byte("x"), targetBytes-8)
		data := make([]byte, 0, targetBytes)
		data = append(data, []byte(`{"a":"`)...)
		data = append(data, body...)
		data = append(data, []byte(`"}`)...)
		runDoSCase(t, "Get", data, func() { _, _, _, _ = Get(data, "a") })
		runDoSCase(t, "GetString", data, func() { _, _ = GetString(data, "a") })
		runDoSCase(t, "ParseString", data, func() {
			val, _, _, _ := Get(data, "a")
			_, _ = ParseString(val)
		})
	})
}

// runDoSCase runs one op under the DoS budget. A panic or a timeout exceeds
// the budget — either is a finding.