google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4: code.Code_value

Clean-room public code sample — generation instructions

Write a brand-new, minimal, self-contained code sample in this clean-room directory.
Do not copy, paraphrase, or reference any existing project source. Work only from this spec.

A csx.json manifest scaffold already exists. Do not recreate it from memory. Preserve its case.goal, packages and symbols; fill its empty case.contract with exact assertions and correct its environment, commands and verifierAdapter for the files you generate.

Goal: verify google.golang.org/genproto/googleapis/rpc/code.Code_value in pkg:golang/google.golang.org/genproto/googleapis/rpc@v0.0.0-20260904194346-d0f1323225a4
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/google.golang.org/genproto/googleapis/rpc@v0.0.0-20260904194346-d0f1323225a4
Demonstrate these symbols/APIs:
  - google.golang.org/genproto/googleapis/rpc/code.Code_value

Rules:
  - One focused purpose; the smallest project that proves the goal.
  - Include a contract test (test/contract.*) that runs OFFLINE and exits 0 exactly when the goal behavior works.
  - Pin every dependency with a lockfile so resolution is reproducible.
  - No secrets, credentials, or tokens. No real URLs (only example.com or localhost). No absolute paths.
  - No personal names, emails, company names, or project identifiers of any kind.
  - No binaries and no generated output (node_modules, dist, target, venv, .git, .env).
  - Keep it under 200 files and 256KB packed.

package sample

import (
	"google.golang.org/genproto/googleapis/rpc/code"
)

// CodeValue returns the int32 enum value for a gRPC status code name.
func CodeValue(name string) (int32, bool) {
	val, ok := code.Code_value[name]
	return val, ok
}

// AllCodeValues returns a copy of the Code_value map.
func AllCodeValues() map[string]int32 {
	result := make(map[string]int32, len(code.Code_value))
	for k, v := range code.Code_value {
		result[k] = v
	}
	return result
}

{"case":{"caseId":"case:sha256:e3447b94f1c96b54725e31085df4ee0a6ccb867ed01182d2082ea88d98e5cee7","contract":["code.Code_value is a non-nil map from string to int32","code.Code_value maps canonical gRPC status code names to their defined int32 numerical values","code.Code_value maps UNAUTHENTICATED to integer 16 and RESOURCE_EXHAUSTED to integer 8","code.Code_value contains all 17 canonical gRPC status code names matching Code_name inverses","code.Code_value values cast to code.Code match the canonical Code enum constants","code.Code_value lookup for unknown status name returns zero value and false in comma-ok check","sample.CodeValue returns the correct int32 value for valid code names","sample.CodeValue returns false for invalid code names","sample.AllCodeValues returns a map copy matching Code_value"],"goal":"verify google.golang.org/genproto/googleapis/rpc/code.Code_value in pkg:golang/google.golang.org/genproto/googleapis/rpc@v0.0.0-20260904194346-d0f1323225a4","kind":"HOW","packages":["pkg:golang/google.golang.org/genproto/googleapis/rpc@v0.0.0-20260904194346-d0f1323225a4"],"schemaVersion":1,"symbols":["google.golang.org/genproto/googleapis/rpc/code.Code_value"]},"contractCommand":["go","run","./test"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/google.golang.org/genproto/googleapis/rpc@v0.0.0-20260904194346-d0f1323225a4"],"schemaVersion":1,"subject":"pkg:golang/google.golang.org/genproto/googleapis/rpc@v0.0.0-20260904194346-d0f1323225a4","symbols":["google.golang.org/genproto/googleapis/rpc/code.Code_value"],"verifierAdapter":"golang@1"}

module sample

go 1.26.6

require google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4

require google.golang.org/protobuf v1.36.12 // indirect

github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8=
github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU=
google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4 h1:5t+ZydAFj5kGVLrgCvLmpmCf9ylGRd64hpEronfRaws=
google.golang.org/genproto/googleapis/rpc v0.0.0-20260904194346-d0f1323225a4/go.mod h1:DjtHYE8FKJLivXcBEjGwndXfIC23G0VpXiXKqG179uA=
google.golang.org/protobuf v1.36.12 h1:pJOKDDOyeXErUroCihFAd5LQuwXBSpVnKGrj5o/fwxc=
google.golang.org/protobuf v1.36.12/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco=

{
  "schemaVersion": 1,
  "goal": "verify google.golang.org/genproto/googleapis/rpc/code.Code_value in pkg:golang/google.golang.org/genproto/googleapis/rpc@v0.0.0-20260904194346-d0f1323225a4",
  "kind": "HOW",
  "packages": [
    "pkg:golang/google.golang.org/genproto/googleapis/rpc@v0.0.0-20260904194346-d0f1323225a4"
  ],
  "symbols": [
    "google.golang.org/genproto/googleapis/rpc/code.Code_value"
  ]
}

package main

import (
	"fmt"
	"os"

	"google.golang.org/genproto/googleapis/rpc/code"
	"sample"
)

func main() {
	// Assertion 1: code.Code_value is a non-nil map from string to int32
	if code.Code_value == nil {
		fmt.Fprintf(os.Stderr, "expected code.Code_value to be non-nil\n")
		os.Exit(1)
	}

	// Assertion 2: code.Code_value maps canonical gRPC status code names to their defined int32 numerical values
	expectedValues := map[string]int32{
		"OK":                  0,
		"CANCELLED":           1,
		"UNKNOWN":             2,
		"INVALID_ARGUMENT":    3,
		"DEADLINE_EXCEEDED":   4,
		"NOT_FOUND":           5,
		"ALREADY_EXISTS":      6,
		"PERMISSION_DENIED":   7,
		"RESOURCE_EXHAUSTED":  8,
		"FAILED_PRECONDITION": 9,
		"ABORTED":             10,
		"OUT_OF_RANGE":        11,
		"UNIMPLEMENTED":       12,
		"INTERNAL":            13,
		"UNAVAILABLE":         14,
		"DATA_LOSS":           15,
		"UNAUTHENTICATED":     16,
	}
	for name, expected := range expectedValues {
		val, ok := code.Code_value[name]
		if !ok {
			fmt.Fprintf(os.Stderr, "code.Code_value missing expected key %q\n", name)
			os.Exit(1)
		}
		if val != expected {
			fmt.Fprintf(os.Stderr, "code.Code_value[%q] = %d; want %d\n", name, val, expected)
			os.Exit(1)
		}
	}

	// Assertion 3: code.Code_value maps UNAUTHENTICATED to integer 16 and RESOURCE_EXHAUSTED to integer 8
	if val := code.Code_value["UNAUTHENTICATED"]; val != 16 {
		fmt.Fprintf(os.Stderr, "expected UNAUTHENTICATED to be 16, got %d\n", val)
		os.Exit(1)
	}
	if val := code.Code_value["RESOURCE_EXHAUSTED"]; val != 8 {
		fmt.Fprintf(os.Stderr, "expected RESOURCE_EXHAUSTED to be 8, got %d\n", val)
		os.Exit(1)
	}

	// Assertion 4: code.Code_value contains all 17 canonical gRPC status code names matching Code_name inverses
	if len(code.Code_value) != 17 {
		fmt.Fprintf(os.Stderr, "expected 17 entries in code.Code_value, got %d\n", len(code.Code_value))
		os.Exit(1)
	}
	for name, val := range code.Code_value {
		mappedName, ok := code.Code_name[val]
		if !ok {
			fmt.Fprintf(os.Stderr, "code.Code_name has no entry for code.Code_value %d (%s)\n", val, name)
			os.Exit(1)
		}
		if mappedName != name {
			fmt.Fprintf(os.Stderr, "code.Code_name[%d] = %q; want %q\n", val, mappedName, name)
			os.Exit(1)
		}
	}

	// Assertion 5: code.Code_value values cast to code.Code match the canonical Code enum constants
	enumChecks := []struct {
		name     string
		expected code.Code
	}{
		{"OK", code.Code_OK},
		{"CANCELLED", code.Code_CANCELLED},
		{"UNKNOWN", code.Code_UNKNOWN},
		{"INVALID_ARGUMENT", code.Code_INVALID_ARGUMENT},
		{"DEADLINE_EXCEEDED", code.Code_DEADLINE_EXCEEDED},
		{"NOT_FOUND", code.Code_NOT_FOUND},
		{"ALREADY_EXISTS", code.Code_ALREADY_EXISTS},
		{"PERMISSION_DENIED", code.Code_PERMISSION_DENIED},
		{"UNAUTHENTICATED", code.Code_UNAUTHENTICATED},
		{"RESOURCE_EXHAUSTED", code.Code_RESOURCE_EXHAUSTED},
		{"FAILED_PRECONDITION", code.Code_FAILED_PRECONDITION},
		{"ABORTED", code.Code_ABORTED},
		{"OUT_OF_RANGE", code.Code_OUT_OF_RANGE},
		{"UNIMPLEMENTED", code.Code_UNIMPLEMENTED},
		{"INTERNAL", code.Code_INTERNAL},
		{"UNAVAILABLE", code.Code_UNAVAILABLE},
		{"DATA_LOSS", code.Code_DATA_LOSS},
	}
	for _, check := range enumChecks {
		val, ok := code.Code_value[check.name]
		if !ok {
			fmt.Fprintf(os.Stderr, "code.Code_value missing key %q during enum check\n", check.name)
			os.Exit(1)
		}
		if code.Code(val) != check.expected {
			fmt.Fprintf(os.Stderr, "code.Code(code.Code_value[%q]) = %v; want %v\n", check.name, code.Code(val), check.expected)
			os.Exit(1)
		}
	}

	// Assertion 6: code.Code_value lookup for unknown status name returns zero value and false in comma-ok check
	if val, ok := code.Code_value["UNKNOWN_ERROR_CUSTOM"]; ok || val != 0 {
		fmt.Fprintf(os.Stderr, "code.Code_value lookup for nonexistent key returned val=%d, ok=%v; want 0, false\n", val, ok)
		os.Exit(1)
	}

	// Assertion 7: sample.CodeValue returns the correct int32 value for valid code names
	if val, ok := sample.CodeValue("NOT_FOUND"); !ok || val != int32(code.Code_NOT_FOUND) {
		fmt.Fprintf(os.Stderr, "expected sample.CodeValue(\"NOT_FOUND\") to be (%d, true), got (%d, %v)\n", int32(code.Code_NOT_FOUND), val, ok)
		os.Exit(1)
	}

	// Assertion 8: sample.CodeValue returns false for invalid code names
	if _, ok := sample.CodeValue("INVALID_CUSTOM_CODE"); ok {
		fmt.Fprintf(os.Stderr, "expected sample.CodeValue(\"INVALID_CUSTOM_CODE\") to return ok=false\n")
		os.Exit(1)
	}

	// Assertion 9: sample.AllCodeValues returns a map copy matching Code_value
	all := sample.AllCodeValues()
	if len(all) != len(code.Code_value) {
		fmt.Fprintf(os.Stderr, "expected sample.AllCodeValues() length %d, got %d\n", len(code.Code_value), len(all))
		os.Exit(1)
	}
	for k, v := range code.Code_value {
		if all[k] != v {
			fmt.Fprintf(os.Stderr, "mismatch in AllCodeValues for key %q: expected %d, got %d\n", k, v, all[k])
			os.Exit(1)
		}
	}

	fmt.Println("PASS: all contract assertions satisfied")
}