strconv — validation proof

Go’s own strconv test suite, converted to C# by go2cs, built against the converted standard library, run under the Go-semantics test host, and compared verdict for verdict against a clean go test -json baseline of the same sources. This page is generated by the converter from that comparison — it is the evidence behind the strconv row in Validated Test Packages.

Validated 2026-09-23 · converter f95f88866

55 matched · 11 disclosed — Go 1.24.13, windows/amd64, converted package src/core/strconv.

Measured at Release (tiered JIT off), oracle go version go1.24.13 windows/amd64.

Both runtimes skip 1 of the matched tests identically.

Verdicts

Test	go test	go2cs
TestAllocationsFromBytes	pass	fail (disclosed)
TestAllocationsFromBytes/AppendQuote	pass	fail (disclosed)
TestAllocationsFromBytes/AppendQuoteToASCII	pass	fail (disclosed)
TestAllocationsFromBytes/AppendQuoteToGraphic	pass	fail (disclosed)
TestAllocationsFromBytes/Atoi	pass	fail (disclosed)
TestAllocationsFromBytes/CanBackquote	pass	fail (disclosed)
TestAllocationsFromBytes/ParseBool	pass	fail (disclosed)
TestAllocationsFromBytes/ParseComplex	pass	fail (disclosed)
TestAllocationsFromBytes/ParseFloat	pass	fail (disclosed)
TestAllocationsFromBytes/ParseInt	pass	fail (disclosed)
TestAllocationsFromBytes/ParseUint	pass	fail (disclosed)
TestAppendBool	pass	pass
TestAtof	pass	pass
TestAtofRandom	pass	pass
TestAtofSlow	pass	pass
TestAtoi	pass	pass
TestCanBackquote	pass	pass
TestCountMallocs	skip	skip
TestDecimalRound	pass	pass
TestDecimalRoundedInteger	pass	pass
TestDecimalShift	pass	pass
TestErrorPrefixes	pass	pass
TestFormatBool	pass	pass
TestFormatComplex	pass	pass
TestFormatComplexInvalidBitSize	pass	pass
TestFormatFloatInvalidBitSize	pass	pass
TestFormatUintVarlen	pass	pass
TestFp	pass	pass
TestFtoa	pass	pass
TestFtoaPowersOfTwo	pass	pass
TestFtoaRandom	pass	pass
TestIsGraphic	pass	pass
TestIsPrint	pass	pass
TestItoa	pass	pass
TestMulByLog10Log2	pass	pass
TestMulByLog2Log10	pass	pass
TestNumError	pass	pass
TestNumErrorUnwrap	pass	pass
TestParseBool	pass	pass
TestParseComplex	pass	pass
TestParseComplexIncorrectBitSize	pass	pass
TestParseFloatIncorrectBitSize	pass	pass
TestParseFloatPrefix	pass	pass
TestParseInt	pass	pass
TestParseInt32	pass	pass
TestParseInt64	pass	pass
TestParseInt64Base	pass	pass
TestParseIntBase	pass	pass
TestParseIntBitSize	pass	pass
TestParseUint	pass	pass
TestParseUint32	pass	pass
TestParseUint64	pass	pass
TestParseUint64Base	pass	pass
TestParseUintBase	pass	pass
TestParseUintBitSize	pass	pass
TestQuote	pass	pass
TestQuoteRune	pass	pass
TestQuoteRuneToASCII	pass	pass
TestQuoteRuneToGraphic	pass	pass
TestQuoteToASCII	pass	pass
TestQuoteToGraphic	pass	pass
TestRoundTrip	pass	pass
TestRoundTrip32	pass	pass
TestUitoa	pass	pass
TestUnquote	pass	pass
TestUnquoteInvalidUTF8	pass	pass

Disclosed divergences

A disclosed divergence is a specific Go assertion this conversion does not satisfy — not a skipped test and not a tolerance. Each one is pinned by exact failure signature in the package’s hand-owned go2cs_test_disclosures.json; a disclosed test that fails any other way is still a hard mismatch.

The Class column says which kind each one is: a deferred entry is an assertion the managed CLR can meet, pinned against the named plan that will retire it; every other class is one it provably cannot satisfy.

Test	Class	Pinned reason
TestAllocationsFromBytes	aggregate	no failure text of its own — the roll-up of this test’s disclosed subtests
TestAllocationsFromBytes/AppendQuote	deferred	want-zero AllocsPerRun assert: the closure’s string([]byte) argument is proven non-escaping by Go’s compiler and stays on the stack; the managed model must materialize an @string per run before the pre-sized append. RELABEL 2026-09-23 (C1, from the i7 reading run at bb54ff0920, Release with tiering off): alloc-profile -> deferred. The run’s own unit note is COUNT, so golib’s counter SAW these objects – the COUNT arm of the 2026-09-05 ladder – and the site family is one a named plan removes: string-conversion intermediates. Read at Atoi (src/core/strconv/atoi.cs:255-267): the test’s string(bytes.Number) argument, the function-local "Atoi"u8 constant materialised per call, and range []byte(s) copied through slice(s) -- three conversions Go performs without a heap object, which is Atoi's reading of 3. Only Atoi was decomposed; the other nine share the argument site.
TestAllocationsFromBytes/AppendQuoteToASCII	deferred	want-zero AllocsPerRun assert: the closure’s string([]byte) argument is proven non-escaping by Go’s compiler and stays on the stack; the managed model must materialize an @string per run before the pre-sized append. RELABEL 2026-09-23 (C1, from the i7 reading run at bb54ff0920, Release with tiering off): alloc-profile -> deferred. The run’s own unit note is COUNT, so golib’s counter SAW these objects – the COUNT arm of the 2026-09-05 ladder – and the site family is one a named plan removes: string-conversion intermediates. Read at Atoi (src/core/strconv/atoi.cs:255-267): the test’s string(bytes.Number) argument, the function-local "Atoi"u8 constant materialised per call, and range []byte(s) copied through slice(s) -- three conversions Go performs without a heap object, which is Atoi's reading of 3. Only Atoi was decomposed; the other nine share the argument site.
TestAllocationsFromBytes/AppendQuoteToGraphic	deferred	want-zero AllocsPerRun assert: the closure’s string([]byte) argument is proven non-escaping by Go’s compiler and stays on the stack; the managed model must materialize an @string per run before the pre-sized append. RELABEL 2026-09-23 (C1, from the i7 reading run at bb54ff0920, Release with tiering off): alloc-profile -> deferred. The run’s own unit note is COUNT, so golib’s counter SAW these objects – the COUNT arm of the 2026-09-05 ladder – and the site family is one a named plan removes: string-conversion intermediates. Read at Atoi (src/core/strconv/atoi.cs:255-267): the test’s string(bytes.Number) argument, the function-local "Atoi"u8 constant materialised per call, and range []byte(s) copied through slice(s) -- three conversions Go performs without a heap object, which is Atoi's reading of 3. Only Atoi was decomposed; the other nine share the argument site.
TestAllocationsFromBytes/Atoi	deferred	want-zero AllocsPerRun assert: the closure’s string([]byte) argument is proven non-escaping by Go’s compiler and stays on the stack; the managed model must materialize an @string per run. RELABEL 2026-09-23 (C1, from the i7 reading run at bb54ff0920, Release with tiering off): alloc-profile -> deferred. The run’s own unit note is COUNT, so golib’s counter SAW these objects – the COUNT arm of the 2026-09-05 ladder – and the site family is one a named plan removes: string-conversion intermediates. Read at Atoi (src/core/strconv/atoi.cs:255-267): the test’s string(bytes.Number) argument, the function-local "Atoi"u8 constant materialised per call, and range []byte(s) copied through slice(s) -- three conversions Go performs without a heap object, which is Atoi's reading of 3. Only Atoi was decomposed; the other nine share the argument site.
TestAllocationsFromBytes/CanBackquote	deferred	want-zero AllocsPerRun assert: the closure’s string([]byte) argument is proven non-escaping by Go’s compiler and stays on the stack; the managed model must materialize an @string per run. RELABEL 2026-09-23 (C1, from the i7 reading run at bb54ff0920, Release with tiering off): alloc-profile -> deferred. The run’s own unit note is COUNT, so golib’s counter SAW these objects – the COUNT arm of the 2026-09-05 ladder – and the site family is one a named plan removes: string-conversion intermediates. Read at Atoi (src/core/strconv/atoi.cs:255-267): the test’s string(bytes.Number) argument, the function-local "Atoi"u8 constant materialised per call, and range []byte(s) copied through slice(s) -- three conversions Go performs without a heap object, which is Atoi's reading of 3. Only Atoi was decomposed; the other nine share the argument site.
TestAllocationsFromBytes/ParseBool	deferred	want-zero AllocsPerRun assert: the closure’s string([]byte) argument is proven non-escaping by Go’s compiler and stays on the stack; the managed model must materialize an @string per run. RELABEL 2026-09-23 (C1, from the i7 reading run at bb54ff0920, Release with tiering off): alloc-profile -> deferred. The run’s own unit note is COUNT, so golib’s counter SAW these objects – the COUNT arm of the 2026-09-05 ladder – and the site family is one a named plan removes: string-conversion intermediates. Read at Atoi (src/core/strconv/atoi.cs:255-267): the test’s string(bytes.Number) argument, the function-local "Atoi"u8 constant materialised per call, and range []byte(s) copied through slice(s) -- three conversions Go performs without a heap object, which is Atoi's reading of 3. Only Atoi was decomposed; the other nine share the argument site.
TestAllocationsFromBytes/ParseComplex	deferred	want-zero AllocsPerRun assert: the closure’s string([]byte) argument is proven non-escaping by Go’s compiler and stays on the stack; the managed model must materialize an @string per run. RELABEL 2026-09-23 (C1, from the i7 reading run at bb54ff0920, Release with tiering off): alloc-profile -> deferred. The run’s own unit note is COUNT, so golib’s counter SAW these objects – the COUNT arm of the 2026-09-05 ladder – and the site family is one a named plan removes: string-conversion intermediates. Read at Atoi (src/core/strconv/atoi.cs:255-267): the test’s string(bytes.Number) argument, the function-local "Atoi"u8 constant materialised per call, and range []byte(s) copied through slice(s) -- three conversions Go performs without a heap object, which is Atoi's reading of 3. Only Atoi was decomposed; the other nine share the argument site.
TestAllocationsFromBytes/ParseFloat	deferred	want-zero AllocsPerRun assert: the closure’s string([]byte) argument is proven non-escaping by Go’s compiler and stays on the stack; the managed model must materialize an @string per run. RELABEL 2026-09-23 (C1, from the i7 reading run at bb54ff0920, Release with tiering off): alloc-profile -> deferred. The run’s own unit note is COUNT, so golib’s counter SAW these objects – the COUNT arm of the 2026-09-05 ladder – and the site family is one a named plan removes: string-conversion intermediates. Read at Atoi (src/core/strconv/atoi.cs:255-267): the test’s string(bytes.Number) argument, the function-local "Atoi"u8 constant materialised per call, and range []byte(s) copied through slice(s) -- three conversions Go performs without a heap object, which is Atoi's reading of 3. Only Atoi was decomposed; the other nine share the argument site.
TestAllocationsFromBytes/ParseInt	deferred	want-zero AllocsPerRun assert: the closure’s string([]byte) argument is proven non-escaping by Go’s compiler and stays on the stack; the managed model must materialize an @string per run. RELABEL 2026-09-23 (C1, from the i7 reading run at bb54ff0920, Release with tiering off): alloc-profile -> deferred. The run’s own unit note is COUNT, so golib’s counter SAW these objects – the COUNT arm of the 2026-09-05 ladder – and the site family is one a named plan removes: string-conversion intermediates. Read at Atoi (src/core/strconv/atoi.cs:255-267): the test’s string(bytes.Number) argument, the function-local "Atoi"u8 constant materialised per call, and range []byte(s) copied through slice(s) -- three conversions Go performs without a heap object, which is Atoi's reading of 3. Only Atoi was decomposed; the other nine share the argument site.
TestAllocationsFromBytes/ParseUint	deferred	want-zero AllocsPerRun assert: the closure’s string([]byte) argument is proven non-escaping by Go’s compiler and stays on the stack; the managed model must materialize an @string per run. RELABEL 2026-09-23 (C1, from the i7 reading run at bb54ff0920, Release with tiering off): alloc-profile -> deferred. The run’s own unit note is COUNT, so golib’s counter SAW these objects – the COUNT arm of the 2026-09-05 ladder – and the site family is one a named plan removes: string-conversion intermediates. Read at Atoi (src/core/strconv/atoi.cs:255-267): the test’s string(bytes.Number) argument, the function-local "Atoi"u8 constant materialised per call, and range []byte(s) copied through slice(s) -- three conversions Go performs without a heap object, which is Atoi's reading of 3. Only Atoi was decomposed; the other nine share the argument site.

Excluded declarations

Declarations filtered from both sides of the comparison, and therefore not claimed above: Benchmark, Fuzz and Example declarations the converted host does not execute, plus any test requiring a capability the managed runtime does not provide — a testing member the host has not implemented, or a platform behavior it provably cannot reproduce. Each is named with the capability it needs.

• BenchmarkAppendFloat (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkAppendInt (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkAppendIntSmall (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkAppendQuote (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkAppendQuoteRune (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkAppendUint (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkAppendUintVarlen (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkAtof32Decimal (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkAtof32Float (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkAtof32FloatExp (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkAtof32Random (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkAtof32RandomLong (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkAtof64Big (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkAtof64Decimal (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkAtof64Float (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkAtof64FloatExp (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkAtof64RandomBits (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkAtof64RandomFloats (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkAtof64RandomLongFloats (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkAtoi (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkFormatFloat (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkFormatInt (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkFormatIntSmall (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkFormatUint (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkParseInt (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkQuote (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkQuoteRune (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkUnquoteEasy (benchmark): benchmark execution is deferred to Phase 4D
• BenchmarkUnquoteHard (benchmark): benchmark execution is deferred to Phase 4D
• ExampleAppendBool (example): example execution is deferred to Phase 4D
• ExampleAppendFloat (example): example execution is deferred to Phase 4D
• ExampleAppendInt (example): example execution is deferred to Phase 4D
• ExampleAppendQuote (example): example execution is deferred to Phase 4D
• ExampleAppendQuoteRune (example): example execution is deferred to Phase 4D
• ExampleAppendQuoteRuneToASCII (example): example execution is deferred to Phase 4D
• ExampleAppendQuoteToASCII (example): example execution is deferred to Phase 4D
• ExampleAppendUint (example): example execution is deferred to Phase 4D
• ExampleAtoi (example): example execution is deferred to Phase 4D
• ExampleCanBackquote (example): example execution is deferred to Phase 4D
• ExampleFormatBool (example): example execution is deferred to Phase 4D
• ExampleFormatFloat (example): example execution is deferred to Phase 4D
• ExampleFormatInt (example): example execution is deferred to Phase 4D
• ExampleFormatUint (example): example execution is deferred to Phase 4D
• ExampleIsGraphic (example): example execution is deferred to Phase 4D
• ExampleIsPrint (example): example execution is deferred to Phase 4D
• ExampleItoa (example): example execution is deferred to Phase 4D
• ExampleNumError (example): example execution is deferred to Phase 4D
• ExampleParseBool (example): example execution is deferred to Phase 4D
• ExampleParseFloat (example): example execution is deferred to Phase 4D
• ExampleParseInt (example): example execution is deferred to Phase 4D
• ExampleParseUint (example): example execution is deferred to Phase 4D
• ExampleQuote (example): example execution is deferred to Phase 4D
• ExampleQuoteRune (example): example execution is deferred to Phase 4D
• ExampleQuoteRuneToASCII (example): example execution is deferred to Phase 4D
• ExampleQuoteRuneToGraphic (example): example execution is deferred to Phase 4D
• ExampleQuoteToASCII (example): example execution is deferred to Phase 4D
• ExampleQuoteToGraphic (example): example execution is deferred to Phase 4D
• ExampleQuotedPrefix (example): example execution is deferred to Phase 4D
• ExampleUnquote (example): example execution is deferred to Phase 4D
• ExampleUnquoteChar (example): example execution is deferred to Phase 4D