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-10-25 · converter 3e3f18925

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

Measured at Release (tiered JIT off), oracle go version go1.26.10 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
TestAtoi pass pass
TestCanBackquote pass pass
TestCountMallocs skip skip
TestErrorPrefixes pass pass
TestFormatBool pass pass
TestFormatComplex pass pass
TestFormatComplexInvalidBitSize pass pass
TestFormatUintVarlen pass pass
TestIsGraphic pass pass
TestIsPrint pass pass
TestItoa pass pass
TestNumError pass pass
TestNumErrorUnwrap pass pass
TestParseBool pass pass
TestParseComplex pass pass
TestParseComplexIncorrectBitSize 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
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 materializes an @string per run before the pre-sized append. The site family is string-conversion intermediates, which a converter change can remove, decomposed at Atoi (src/core/strconv/atoi.cs:255-267) as the test’s string(bytes.Number) argument, the function-local "Atoi"u8 constant materialized per call, and range []byte(s) copied through slice(s): three conversions Go performs without a heap object. This subtest shares the argument site; only Atoi's path is decomposed.
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 materializes an @string per run before the pre-sized append. The site family is string-conversion intermediates, which a converter change can remove, decomposed at Atoi (src/core/strconv/atoi.cs:255-267) as the test’s string(bytes.Number) argument, the function-local "Atoi"u8 constant materialized per call, and range []byte(s) copied through slice(s): three conversions Go performs without a heap object. This subtest shares the argument site; only Atoi's path is decomposed.
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 materializes an @string per run before the pre-sized append. The site family is string-conversion intermediates, which a converter change can remove, decomposed at Atoi (src/core/strconv/atoi.cs:255-267) as the test’s string(bytes.Number) argument, the function-local "Atoi"u8 constant materialized per call, and range []byte(s) copied through slice(s): three conversions Go performs without a heap object. This subtest shares the argument site; only Atoi's path is decomposed.
TestAllocationsFromBytes/Atoi deferred Want-zero AllocsPerRun assert: the test’s string(bytes.Number) argument is proven non-escaping by Go’s compiler and stays on the stack; the managed model materializes an @string per run. Read at Atoi (src/core/strconv/atoi.cs:255-267), the counted objects are that argument, the function-local "Atoi"u8 constant materialized per call, and range []byte(s) copied through slice(s): three conversions Go performs without a heap object, Atoi's 3 per run at go1.24.13. It reads 2 per run at go1.26.10 on windows and linux (identical test body). These string-conversion intermediates are removable by a converter change.
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 materializes an @string per run. The site family is string-conversion intermediates, which a converter change can remove, decomposed at Atoi (src/core/strconv/atoi.cs:255-267) as the test’s string(bytes.Number) argument, the function-local "Atoi"u8 constant materialized per call, and range []byte(s) copied through slice(s): three conversions Go performs without a heap object. This subtest shares the argument site; only Atoi's path is decomposed.
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 materializes an @string per run. The site family is string-conversion intermediates, which a converter change can remove, decomposed at Atoi (src/core/strconv/atoi.cs:255-267) as the test’s string(bytes.Number) argument, the function-local "Atoi"u8 constant materialized per call, and range []byte(s) copied through slice(s): three conversions Go performs without a heap object. This subtest shares the argument site; only Atoi's path is decomposed.
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 materializes an @string per run. The site family is string-conversion intermediates, which a converter change can remove, decomposed at Atoi (src/core/strconv/atoi.cs:255-267) as the test’s string(bytes.Number) argument, the function-local "Atoi"u8 constant materialized per call, and range []byte(s) copied through slice(s): three conversions Go performs without a heap object. This subtest shares the argument site; only Atoi's path is decomposed.
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 materializes an @string per run. The site family is string-conversion intermediates, which a converter change can remove, decomposed at Atoi (src/core/strconv/atoi.cs:255-267) as the test’s string(bytes.Number) argument, the function-local "Atoi"u8 constant materialized per call, and range []byte(s) copied through slice(s): three conversions Go performs without a heap object. This subtest shares the argument site; only Atoi's path is decomposed.
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 materializes an @string per run. The site family is string-conversion intermediates, which a converter change can remove, decomposed at Atoi (src/core/strconv/atoi.cs:255-267) as the test’s string(bytes.Number) argument, the function-local "Atoi"u8 constant materialized per call, and range []byte(s) copied through slice(s): three conversions Go performs without a heap object. This subtest shares the argument site; only Atoi's path is decomposed. It reads 2 per run at go1.26.10 on windows and linux (4 at go1.24.13; identical test body).
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 materializes an @string per run. The site family is string-conversion intermediates, which a converter change can remove, decomposed at Atoi (src/core/strconv/atoi.cs:255-267) as the test’s string(bytes.Number) argument, the function-local "Atoi"u8 constant materialized per call, and range []byte(s) copied through slice(s): three conversions Go performs without a heap object. This subtest shares the argument site; only Atoi's path is decomposed. It reads 2 per run at go1.26.10 on windows and linux (3 at go1.24.13; identical test body).

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.