Function TestOracleParseBoolean

reference_oracle_test.go:883–929

reqproof:proptest ParseBoolean Verifies: SYS-REQ-012 [property]

(t *testing.T)

// reqproof:proptest ParseBoolean
// Verifies: SYS-REQ-012 [property]
func TestOracleParseBoolean(t *testing.T) {
	// The valid JSON booleans are exactly "true" and "false" (RFC 8259).
	// jsonparser correctly accepts only those. Assert exact value match
	// on the strict-JSON subset (the only inputs both parsers should accept
	// under JSON semantics — see divergence D2 in the file header).
	for _, tc := range []struct {
		tok string
		val bool
	}{
		{"true", true},
		{"false", false},
	} {
		got, err := ParseBoolean([]byte(tc.tok))
		if err != nil {
			t.Fatalf("ParseBoolean rejected %q: %v", tc.tok, err)
		}
		if got != tc.val {
			t.Fatalf("ParseBoolean(%q) = %v, want %v", tc.tok, got, tc.val)
		}
	}

	// Adversarial inputs: assert agreement on the common-acceptance domain.
	// jsonparser follows strict JSON; strconv accepts Go-idiomatic forms
	// (t/f/T/F/1/0/TRUE/FALSE). When both accept, values must match.
	rb := func(b []byte) bool {
		s := string(b)
		_, refErr := strconv.ParseBool(s)
		_, err := ParseBoolean([]byte(s))
		// If strconv rejects, jsonparser may also reject — that's fine.
		if refErr != nil {
			return true
		}
		// strconv accepted. jsonparser may reject (narrower JSON grammar)
		// — that's a documented divergence, not a bug. But if jsonparser
		// ALSO accepts, the value must match.
		if err != nil {
			return true
		}
		// Re-fetch both for comparison.
		ref, _ := strconv.ParseBool(s)
		got, _ := ParseBoolean([]byte(s))
		return got == ref
	}
	if err := quick.Check(rb, &quick.Config{MaxCount: 5000}); err != nil {
		t.Fatalf("ParseBoolean diverges from strconv on commonly-accepted input: %v", err)
	}
}

// closeEnoughFloat reports whether two float64 values agree to within a
// relative tolerance of ~4 ULP — used only for adversarial inputs where