proof: enable all checks at warn level; drop bogus test-function proptest annotations

Enable every remaining audit check at severity: warning so the surface
is fully honest (no silently-disabled gates). flip_fixtures_exist stays
disabled (not applicable to a parser library).

Remove 634 // reqproof:proptest:skip annotations that had been added to
TEST functions (Test*/Benchmark*) — test functions are not property-test
subjects, and annotating them was noise. property_based_test_coverage
still reports these as INFO-level gaps because the check scans test
functions with no clean opt-out (verification_scope.exclude is shared
with evidence/acceptance checks that read annotations from test files).
Filed as probelabs/reqproof#968.

Audit: 0 errors, 0 warnings, 3 info (property_based_test_coverage INFO
pending the proof-side fix + flip_fixtures disabled + legacy-field
advisory).

Author: buger

bytes_test.go

@@ -102,7 +102,6 @@ var parseIntTests = []ParseIntTest{
 
 // Verifies: SYS-REQ-015 [boundary]
 // MCDC SYS-REQ-015: N/A
-// reqproof:proptest:skip test-case harness function; is itself a unit/integration test, not a pure function amenable to property-based testing
 func TestBytesParseInt(t *testing.T) {
 	for _, test := range parseIntTests {
 		out, ok, overflow := parseInt([]byte(test.in))
@@ -119,7 +118,6 @@ func TestBytesParseInt(t *testing.T) {
 
 // Verifies: SYS-REQ-015 [example]
 // MCDC SYS-REQ-015: N/A
-// reqproof:proptest:skip performance benchmark; measures wall-clock time and allocations, output is non-deterministic and not comparable to an independent reference
 func BenchmarkParseInt(b *testing.B) {
 	bytes := []byte("123")
 	for i := 0; i < b.N; i++ {
@@ -130,7 +128,6 @@ func BenchmarkParseInt(b *testing.B) {
 // Alternative implementation using unsafe and delegating to strconv.ParseInt
 // Verifies: SYS-REQ-015 [example]
 // MCDC SYS-REQ-015: N/A
-// reqproof:proptest:skip performance benchmark; measures wall-clock time and allocations, output is non-deterministic and not comparable to an independent reference
 func BenchmarkParseIntUnsafeSlower(b *testing.B) {
 	bytes := []byte("123")
 	for i := 0; i < b.N; i++ {
@@ -141,7 +138,6 @@ func BenchmarkParseIntUnsafeSlower(b *testing.B) {
 // Old implementation that did not check for overflows.
 // Verifies: SYS-REQ-015 [example]
 // MCDC SYS-REQ-015: N/A
-// reqproof:proptest:skip performance benchmark; measures wall-clock time and allocations, output is non-deterministic and not comparable to an independent reference
 func BenchmarkParseIntOverflows(b *testing.B) {
 	bytes := []byte("123")
 	for i := 0; i < b.N; i++ {
@@ -150,7 +146,6 @@ func BenchmarkParseIntOverflows(b *testing.B) {
 }
 
 // Test helper for SYS-REQ-015.
-// reqproof:proptest:skip test-helper checking overflow classification on a fixed sample set; assertion utility with no independently observable pure contract
 func parseIntOverflows(bytes []byte) (v int64, ok bool) {
 	if len(bytes) == 0 {
 		return 0, false

bytes_unsafe_test.go

@@ -18,13 +18,11 @@ var (
 )
 
 // Test helper for SYS-REQ-001 and SYS-REQ-008.
-// reqproof:proptest:skip test-helper wrapping the safe equalStr implementation; thin delegation already covered by the underlying production function
 func bytesEqualStrSafe(abytes []byte, bstr string) bool {
 	return bstr == string(abytes)
 }
 
 // Test helper for SYS-REQ-001 and SYS-REQ-008.
-// reqproof:proptest:skip test-helper wrapping the unsafe equalStr implementation; thin delegation already covered by the underlying production function
 func bytesEqualStrUnsafeSlower(abytes *[]byte, bstr string) bool {
 	aslicehdr := (*reflect.SliceHeader)(unsafe.Pointer(abytes))
 	astrhdr := reflect.StringHeader{Data: aslicehdr.Data, Len: aslicehdr.Len}
@@ -33,7 +31,6 @@ func bytesEqualStrUnsafeSlower(abytes *[]byte, bstr string) bool {
 
 // Verifies: SYS-REQ-001
 // MCDC SYS-REQ-001: N/A
-// reqproof:proptest:skip test-case harness function; is itself a unit/integration test, not a pure function amenable to property-based testing
 func TestEqual(t *testing.T) {
 	if !equalStr(&[]byte{}, "") {
 		t.Errorf(`equalStr("", ""): expected true, obtained false`)
@@ -58,7 +55,6 @@ func TestEqual(t *testing.T) {
 
 // Verifies: SYS-REQ-001
 // MCDC SYS-REQ-001: N/A
-// reqproof:proptest:skip performance benchmark; measures wall-clock time and allocations, output is non-deterministic and not comparable to an independent reference
 func BenchmarkEqualStr(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		equalStr(&benchmarkBytes, benchmarkString)
@@ -68,7 +64,6 @@ func BenchmarkEqualStr(b *testing.B) {
 // Alternative implementation without using unsafe
 // Verifies: SYS-REQ-001
 // MCDC SYS-REQ-001: N/A
-// reqproof:proptest:skip performance benchmark; measures wall-clock time and allocations, output is non-deterministic and not comparable to an independent reference
 func BenchmarkBytesEqualStrSafe(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		bytesEqualStrSafe(benchmarkBytes, benchmarkString)
@@ -78,7 +73,6 @@ func BenchmarkBytesEqualStrSafe(b *testing.B) {
 // Alternative implementation using unsafe, but that is slower than the current implementation
 // Verifies: SYS-REQ-001
 // MCDC SYS-REQ-001: N/A
-// reqproof:proptest:skip performance benchmark; measures wall-clock time and allocations, output is non-deterministic and not comparable to an independent reference
 func BenchmarkBytesEqualStrUnsafeSlower(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		bytesEqualStrUnsafeSlower(&benchmarkBytes, benchmarkString)

coverage_closure_test.go

@@ -15,7 +15,6 @@ import (
 
 // Verifies: SYS-REQ-008 [fuzz]
 // MCDC SYS-REQ-008: N/A
-// reqproof:proptest:skip test-case harness function; is itself a unit/integration test, not a pure function amenable to property-based testing
 func TestFuzzEachKeyHarnessCoverage(t *testing.T) {
 	// FuzzEachKey exercises EachKey with 12 hard-coded paths against
 	// arbitrary data. The function always returns 1 regardless of whether
@@ -49,7 +48,6 @@ func TestFuzzEachKeyHarnessCoverage(t *testing.T) {
 
 // Verifies: SYS-REQ-010 [fuzz]
 // MCDC SYS-REQ-010: delete_path_is_provided=T, delete_returns_empty_document_without_path=F => TRUE
-// reqproof:proptest:skip test-case harness function; is itself a unit/integration test, not a pure function amenable to property-based testing
 func TestFuzzDeleteHarnessCoverage(t *testing.T) {
 	// FuzzDelete calls Delete(data, "test") and always returns 1.
 	// Exercise it with data that contains and does not contain the key.
@@ -73,7 +71,6 @@ func TestFuzzDeleteHarnessCoverage(t *testing.T) {
 
 // Verifies: SYS-REQ-007 [fuzz]
 // MCDC SYS-REQ-007: N/A
-// reqproof:proptest:skip test-case harness function; is itself a unit/integration test, not a pure function amenable to property-based testing
 func TestFuzzObjectEachHarnessCoverage(t *testing.T) {
 	// FuzzObjectEach calls ObjectEach with a no-op callback and returns 1.
 	// Exercise it with various inputs covering both branches.
@@ -105,7 +102,6 @@ func TestFuzzObjectEachHarnessCoverage(t *testing.T) {
 
 // Verifies: SYS-REQ-010 [boundary]
 // MCDC SYS-REQ-010: delete_path_is_provided=F, delete_returns_empty_document_without_path=F => FALSE
-// reqproof:proptest:skip test-case harness function; is itself a unit/integration test, not a pure function amenable to property-based testing
 func TestMCDC_SYS_REQ_010_Row1_NoPathNoEmpty(t *testing.T) {
 	// Witness row 1: no path provided AND the function does NOT return an
 	// empty document. This is a requirement violation scenario -- it cannot
@@ -124,7 +120,6 @@ func TestMCDC_SYS_REQ_010_Row1_NoPathNoEmpty(t *testing.T) {
 
 // Verifies: SYS-REQ-010 [boundary]
 // MCDC SYS-REQ-010: delete_path_is_provided=T, delete_returns_empty_document_without_path=F => TRUE
-// reqproof:proptest:skip test-case harness function; is itself a unit/integration test, not a pure function amenable to property-based testing
 func TestMCDC_SYS_REQ_010_Row3_PathProvided(t *testing.T) {
 	// Witness row 3: path IS provided, but delete_returns_empty_document
 	// is FALSE (irrelevant when path is provided). The formula evaluates

dead_code_audit_oob_test.go

@@ -8,7 +8,6 @@ import (
 // after removing the `offset < len(data)` loop guard.
 
 // Verifies: SYS-REQ-007 [boundary]
-// reqproof:proptest:skip test-case harness function; is itself a unit/integration test, not a pure function amenable to property-based testing
 func TestObjectEach_OOB_TruncatedAfterComma(t *testing.T) {
 	// {"a":1, — truncated right after comma, no more data
 	// After parsing "a":1, finds comma at step 4, increments offset past comma.
@@ -25,7 +24,6 @@ func TestObjectEach_OOB_TruncatedAfterComma(t *testing.T) {
 }
 
 // Verifies: SYS-REQ-007 [boundary]
-// reqproof:proptest:skip test-case harness function; is itself a unit/integration test, not a pure function amenable to property-based testing
 func TestObjectEach_OOB_TruncatedAfterColon(t *testing.T) {
 	// {"a": — truncated after colon
 	err := ObjectEach([]byte(`{"a":`), func(key []byte, value []byte, dataType ValueType, offset int) error {
@@ -38,7 +36,6 @@ func TestObjectEach_OOB_TruncatedAfterColon(t *testing.T) {
 }
 
 // Verifies: SYS-REQ-007 [boundary]
-// reqproof:proptest:skip test-case harness function; is itself a unit/integration test, not a pure function amenable to property-based testing
 func TestObjectEach_OOB_TruncatedAfterKey(t *testing.T) {
 	// {"a" — truncated after key string
 	err := ObjectEach([]byte(`{"a"`), func(key []byte, value []byte, dataType ValueType, offset int) error {
@@ -51,7 +48,6 @@ func TestObjectEach_OOB_TruncatedAfterKey(t *testing.T) {
 }
 
 // Verifies: SYS-REQ-007 [boundary]
-// reqproof:proptest:skip test-case harness function; is itself a unit/integration test, not a pure function amenable to property-based testing
 func TestObjectEach_OOB_TruncatedMidKey(t *testing.T) {
 	// {"a — unterminated string
 	err := ObjectEach([]byte(`{"a`), func(key []byte, value []byte, dataType ValueType, offset int) error {
@@ -64,7 +60,6 @@ func TestObjectEach_OOB_TruncatedMidKey(t *testing.T) {
 }
 
 // Verifies: SYS-REQ-007 [boundary]
-// reqproof:proptest:skip test-case harness function; is itself a unit/integration test, not a pure function amenable to property-based testing
 func TestObjectEach_OOB_JustOpenBrace(t *testing.T) {
 	// { — only opening brace, then nothing
 	err := ObjectEach([]byte(`{`), func(key []byte, value []byte, dataType ValueType, offset int) error {
@@ -77,7 +72,6 @@ func TestObjectEach_OOB_JustOpenBrace(t *testing.T) {
 }
 
 // Verifies: SYS-REQ-007 [boundary]
-// reqproof:proptest:skip test-case harness function; is itself a unit/integration test, not a pure function amenable to property-based testing
 func TestObjectEach_OOB_BraceAndWhitespace(t *testing.T) {
 	// {    — opening brace then only whitespace
 	err := ObjectEach([]byte(`{   `), func(key []byte, value []byte, dataType ValueType, offset int) error {
@@ -91,7 +85,6 @@ func TestObjectEach_OOB_BraceAndWhitespace(t *testing.T) {
 
 // ArrayEach infinite loop guard: verify o==0 catches all no-progress cases
 // Verifies: SYS-REQ-006 [boundary]
-// reqproof:proptest:skip test-case harness function; is itself a unit/integration test, not a pure function amenable to property-based testing
 func TestArrayEach_OOB_MalformedElements(t *testing.T) {
 	tests := []struct {
 		name string