golang.org/x/text v0.31.0: ianaindex.MIME

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 golang.org/x/text/encoding/ianaindex.MIME in pkg:golang/golang.org/x/text@v0.31.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/golang.org/x/text@v0.31.0
Demonstrate these symbols/APIs:
  - golang.org/x/text/encoding/ianaindex.MIME

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.

{"case":{"caseId":"case:sha256:3f1ddaca3efa2c983744163a52b3470851337e63243f4770757e0ea26755b86f","contract":["ianaindex.MIME.Encoding resolves standard MIME charset names case-insensitively and returns the corresponding encoding","ianaindex.MIME.Encoding returns an error for unregistered or invalid charset names","ianaindex.MIME.Name returns the canonical MIME name for a supported encoding","an encoding resolved via ianaindex.MIME successfully decodes encoded byte sequences into UTF-8 text","ianaindex.MIME resolves whitespace-padded charset names after trimming"],"goal":"verify golang.org/x/text/encoding/ianaindex.MIME in pkg:golang/golang.org/x/text@v0.31.0","kind":"HOW","packages":["pkg:golang/golang.org/x/text@v0.31.0"],"schemaVersion":1,"symbols":["golang.org/x/text/encoding/ianaindex.MIME"]},"contractCommand":["go","run","./test"],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","language":"go","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","packageManagerVersion":"1.26.6","runtime":"go","runtimeVersion":"1.26.6","schemaVersion":1},"license":"MIT-0","packages":["pkg:golang/golang.org/x/text@v0.31.0"],"schemaVersion":1,"subject":"pkg:golang/golang.org/x/text@v0.31.0","symbols":["golang.org/x/text/encoding/ianaindex.MIME"],"verifierAdapter":"golang@1"}

module sample

go 1.26.6

require golang.org/x/text v0.31.0

golang.org/x/text v0.31.0 h1:aC8ghyu4JhP8VojJ2lEHBnochRno1sgL6nEi9WGFGMM=
golang.org/x/text v0.31.0/go.mod h1:tKRAlv61yKIjGGHX/4tP1LTbc13YSec1pxVEWXzfoeM=

package main

import (
	"fmt"

	"golang.org/x/text/encoding/charmap"
	"golang.org/x/text/encoding/ianaindex"
	"golang.org/x/text/encoding/unicode"
)

func main() {
	// Demonstrating golang.org/x/text/encoding/ianaindex.MIME
	// ianaindex.MIME maps MIME charset names to Encodings and vice versa.

	// 1. Resolve an Encoding by MIME name (case-insensitive)
	enc, err := ianaindex.MIME.Encoding("windows-1252")
	if err != nil {
		fmt.Printf("Encoding lookup error: %v\n", err)
		return
	}

	// 2. Decode Windows-1252 bytes to UTF-8
	win1252Bytes := []byte{0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x80, 0x31, 0x30} // "Hello €10" in Windows-1252
	utf8Text, err := enc.NewDecoder().String(string(win1252Bytes))
	if err != nil {
		fmt.Printf("Decode error: %v\n", err)
		return
	}
	fmt.Printf("Decoded text: %s\n", utf8Text)

	// 3. Resolve canonical MIME name for a supported encoding
	name, err := ianaindex.MIME.Name(charmap.ISO8859_1)
	if err != nil {
		fmt.Printf("Name lookup error: %v\n", err)
		return
	}
	fmt.Printf("Canonical MIME name for ISO8859_1: %s\n", name)

	utf8Name, err := ianaindex.MIME.Name(unicode.UTF8)
	if err != nil {
		fmt.Printf("Name lookup error: %v\n", err)
		return
	}
	fmt.Printf("Canonical MIME name for UTF8: %s\n", utf8Name)

	// 4. Handling unregistered or invalid charset names
	_, err = ianaindex.MIME.Encoding("invalid-charset-xyz")
	if err != nil {
		fmt.Printf("Expected error for invalid charset: %v\n", err)
	}

	fmt.Println("golang.org/x/text/encoding/ianaindex.MIME demonstrated successfully.")
}

{
  "schemaVersion": 1,
  "goal": "verify golang.org/x/text/encoding/ianaindex.MIME in pkg:golang/golang.org/x/text@v0.31.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/golang.org/x/text@v0.31.0"
  ],
  "symbols": [
    "golang.org/x/text/encoding/ianaindex.MIME"
  ]
}

package main

import (
	"bytes"
	"fmt"
	"os"

	"golang.org/x/text/encoding"
	"golang.org/x/text/encoding/charmap"
	"golang.org/x/text/encoding/ianaindex"
	"golang.org/x/text/encoding/unicode"
)

func main() {
	// Assertion 1: ianaindex.MIME.Encoding resolves standard MIME charset names case-insensitively and returns the corresponding encoding
	{
		names := []string{"utf-8", "UTF-8", "windows-1252", "WINDOWS-1252", "iso-8859-1", "ISO-8859-1", "shift_jis"}
		for _, name := range names {
			enc, err := ianaindex.MIME.Encoding(name)
			if err != nil {
				fmt.Fprintf(os.Stderr, "assertion 1 failed: Encoding(%q) returned error: %v\n", name, err)
				os.Exit(1)
			}
			if enc == nil {
				fmt.Fprintf(os.Stderr, "assertion 1 failed: Encoding(%q) returned nil encoding\n", name)
				os.Exit(1)
			}
		}
	}

	// Assertion 2: ianaindex.MIME.Encoding returns an error for unregistered or invalid charset names
	{
		invalidNames := []string{"invalid-charset-xyz", "not-a-real-encoding", "unknown-8859-99"}
		for _, name := range invalidNames {
			enc, err := ianaindex.MIME.Encoding(name)
			if err == nil {
				fmt.Fprintf(os.Stderr, "assertion 2 failed: Encoding(%q) expected error, got nil\n", name)
				os.Exit(1)
			}
			if enc != nil {
				fmt.Fprintf(os.Stderr, "assertion 2 failed: Encoding(%q) returned non-nil encoding on invalid name\n", name)
				os.Exit(1)
			}
		}
	}

	// Assertion 3: ianaindex.MIME.Name returns the canonical MIME name for a supported encoding
	{
		cases := []struct {
			enc  encoding.Encoding
			want string
		}{
			{charmap.ISO8859_1, "ISO-8859-1"},
			{unicode.UTF8, "UTF-8"},
			{charmap.Windows1252, "windows-1252"},
			{charmap.ISO8859_7, "ISO-8859-7"},
		}
		for _, tc := range cases {
			got, err := ianaindex.MIME.Name(tc.enc)
			if err != nil {
				fmt.Fprintf(os.Stderr, "assertion 3 failed: Name returned error: %v\n", err)
				os.Exit(1)
			}
			if got != tc.want {
				fmt.Fprintf(os.Stderr, "assertion 3 failed: Name got %q, want %q\n", got, tc.want)
				os.Exit(1)
			}
		}
	}

	// Assertion 4: an encoding resolved via ianaindex.MIME successfully decodes encoded byte sequences into UTF-8 text
	{
		enc, err := ianaindex.MIME.Encoding("windows-1252")
		if err != nil {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: Encoding(windows-1252) returned error: %v\n", err)
			os.Exit(1)
		}
		// Windows-1252 byte 0x80 is the Euro sign (€, U+20AC, UTF-8: \xe2\x82\xac)
		rawBytes := []byte{0x50, 0x72, 0x69, 0x63, 0x65, 0x3a, 0x20, 0x80, 0x32, 0x35}
		decodedBytes, err := enc.NewDecoder().Bytes(rawBytes)
		if err != nil {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: NewDecoder().Bytes returned error: %v\n", err)
			os.Exit(1)
		}
		expected := []byte("Price: €25")
		if !bytes.Equal(decodedBytes, expected) {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: decoded bytes mismatch. got %q, want %q\n", decodedBytes, expected)
			os.Exit(1)
		}
	}

	// Assertion 5: ianaindex.MIME resolves whitespace-padded charset names after trimming
	{
		paddedNames := []struct {
			padded string
			clean  string
		}{
			{"  utf-8  ", "utf-8"},
			{"  ISO-8859-1\t", "ISO-8859-1"},
		}
		for _, tc := range paddedNames {
			encPadded, err := ianaindex.MIME.Encoding(tc.padded)
			if err != nil {
				fmt.Fprintf(os.Stderr, "assertion 5 failed: Encoding(%q) returned error: %v\n", tc.padded, err)
				os.Exit(1)
			}
			encClean, err := ianaindex.MIME.Encoding(tc.clean)
			if err != nil {
				fmt.Fprintf(os.Stderr, "assertion 5 failed: Encoding(%q) returned error: %v\n", tc.clean, err)
				os.Exit(1)
			}
			if encPadded != encClean {
				fmt.Fprintf(os.Stderr, "assertion 5 failed: padded and clean encodings do not match for %q\n", tc.padded)
				os.Exit(1)
			}
		}
	}

	fmt.Println("All contract assertions passed successfully.")
}