golang.org/x/text v0.31.0: korean.EUCKR

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/korean.EUCKR 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/korean.EUCKR

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:70d749fb4194ce006862ca1d0190c1b714ada1933d675a9cb48c94b9392b35a6","contract":["korean.EUCKR.NewEncoder().Bytes encodes UTF-8 Korean text to expected EUC-KR byte sequence","korean.EUCKR.NewDecoder().Bytes decodes EUC-KR byte sequence to UTF-8 string","korean.EUCKR encoder and decoder preserve ASCII characters unchanged","korean.EUCKR.NewDecoder Reader decodes EUC-KR byte stream from io.Reader to UTF-8","korean.EUCKR.NewEncoder Writer encodes UTF-8 stream to EUC-KR bytes in io.Writer","korean.EUCKR.NewDecoder replaces unmappable or malformed bytes with replacement character"],"goal":"verify golang.org/x/text/encoding/korean.EUCKR 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/korean.EUCKR"]},"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/korean.EUCKR"],"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 (
	"bytes"
	"fmt"
	"io"
	"strings"

	"golang.org/x/text/encoding/korean"
)

func main() {
	// Demonstrating golang.org/x/text/encoding/korean.EUCKR
	// korean.EUCKR provides the EUC-KR encoding for Korean text.

	// 1. Encode UTF-8 text to EUC-KR bytes and strings
	encoder := korean.EUCKR.NewEncoder()
	sampleText := "안녕하세요 세계"
	encodedBytes, err := encoder.Bytes([]byte(sampleText))
	if err != nil {
		fmt.Printf("Encoding error: %v\n", err)
		return
	}
	fmt.Printf("Encoded EUC-KR bytes (%d bytes): %x\n", len(encodedBytes), encodedBytes)

	// 2. Decode EUC-KR bytes back to UTF-8
	decoder := korean.EUCKR.NewDecoder()
	decodedBytes, err := decoder.Bytes(encodedBytes)
	if err != nil {
		fmt.Printf("Decoding error: %v\n", err)
		return
	}
	fmt.Printf("Decoded UTF-8 string: %s\n", string(decodedBytes))

	// 3. Stream decoding using io.Reader
	streamInput := bytes.NewReader(encodedBytes)
	streamReader := decoder.Reader(streamInput)
	streamResult, err := io.ReadAll(streamReader)
	if err != nil {
		fmt.Printf("Stream decode error: %v\n", err)
		return
	}
	fmt.Printf("Stream decoded result: %s\n", string(streamResult))

	// 4. Stream encoding using io.Writer
	var buf bytes.Buffer
	streamWriter := encoder.Writer(&buf)
	_, err = streamWriter.Write([]byte("한글 스트림 인코딩"))
	if err != nil {
		fmt.Printf("Stream encode error: %v\n", err)
		return
	}
	fmt.Printf("Stream encoded buffer len: %d\n", buf.Len())

	// 5. Handling invalid or unmappable sequences
	invalidSeq := []byte{0xff, 0xff}
	replacementOut, err := decoder.Bytes(invalidSeq)
	if err != nil {
		fmt.Printf("Error with invalid sequence: %v\n", err)
		return
	}
	fmt.Printf("Invalid byte replaced with replacement rune: %t\n", strings.ContainsRune(string(replacementOut), '\uFFFD'))

	fmt.Println("golang.org/x/text/encoding/korean.EUCKR demonstrated successfully.")
}

{
  "schemaVersion": 1,
  "goal": "verify golang.org/x/text/encoding/korean.EUCKR 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/korean.EUCKR"
  ]
}

package main

import (
	"bytes"
	"fmt"
	"io"
	"os"
	"strings"

	"golang.org/x/text/encoding/korean"
)

func main() {
	// Assertion 1: korean.EUCKR.NewEncoder().Bytes encodes UTF-8 Korean text to expected EUC-KR byte sequence
	{
		encoder := korean.EUCKR.NewEncoder()
		if encoder == nil {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: NewEncoder returned nil\n")
			os.Exit(1)
		}

		// "가나다" in UTF-8 -> EUC-KR
		// '가': 0xB0 0xA1, '나': 0xB3 0xAA, '다': 0xB4 0xD9
		src := []byte("가나다")
		expected := []byte{0xB0, 0xA1, 0xB3, 0xAA, 0xB4, 0xD9}

		encoded, err := encoder.Bytes(src)
		if err != nil {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: Bytes returned error: %v\n", err)
			os.Exit(1)
		}
		if !bytes.Equal(encoded, expected) {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: got %x, expected %x\n", encoded, expected)
			os.Exit(1)
		}
	}

	// Assertion 2: korean.EUCKR.NewDecoder().Bytes decodes EUC-KR byte sequence to UTF-8 string
	{
		decoder := korean.EUCKR.NewDecoder()
		if decoder == nil {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: NewDecoder returned nil\n")
			os.Exit(1)
		}

		euckrBytes := []byte{0xB0, 0xA1, 0xB3, 0xAA, 0xB4, 0xD9}
		expectedStr := "가나다"

		decodedBytes, err := decoder.Bytes(euckrBytes)
		if err != nil {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: Bytes returned error: %v\n", err)
			os.Exit(1)
		}
		if string(decodedBytes) != expectedStr {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: got %s, expected %s\n", string(decodedBytes), expectedStr)
			os.Exit(1)
		}

		decodedStr, err := decoder.String(string(euckrBytes))
		if err != nil {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: String returned error: %v\n", err)
			os.Exit(1)
		}
		if decodedStr != expectedStr {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: String got %s, expected %s\n", decodedStr, expectedStr)
			os.Exit(1)
		}
	}

	// Assertion 3: korean.EUCKR encoder and decoder preserve ASCII characters unchanged
	{
		asciiText := "Hello, World! 12345 @#$"

		encoder := korean.EUCKR.NewEncoder()
		encoded, err := encoder.String(asciiText)
		if err != nil {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: encoder.String error: %v\n", err)
			os.Exit(1)
		}
		if encoded != asciiText {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: encoded ASCII does not match original\n")
			os.Exit(1)
		}

		decoder := korean.EUCKR.NewDecoder()
		decoded, err := decoder.String(encoded)
		if err != nil {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: decoder.String error: %v\n", err)
			os.Exit(1)
		}
		if decoded != asciiText {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: decoded ASCII does not match original\n")
			os.Exit(1)
		}
	}

	// Assertion 4: korean.EUCKR.NewDecoder Reader decodes EUC-KR byte stream from io.Reader to UTF-8
	{
		// EUC-KR bytes for "대한민국"
		// '대': 0xB4 0xEB, '한': 0xC7 0xD1, '민': 0xB9 0xCE, '국': 0xB1 0xB9
		euckrData := []byte{0xB4, 0xEB, 0xC7, 0xD1, 0xB9, 0xCE, 0xB1, 0xB9}
		rawReader := bytes.NewReader(euckrData)
		wrappedReader := korean.EUCKR.NewDecoder().Reader(rawReader)

		out, err := io.ReadAll(wrappedReader)
		if err != nil {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: io.ReadAll error: %v\n", err)
			os.Exit(1)
		}
		if string(out) != "대한민국" {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: got %q, expected %q\n", string(out), "대한민국")
			os.Exit(1)
		}
	}

	// Assertion 5: korean.EUCKR.NewEncoder Writer encodes UTF-8 stream to EUC-KR bytes in io.Writer
	{
		var buf bytes.Buffer
		wrappedWriter := korean.EUCKR.NewEncoder().Writer(&buf)

		_, err := wrappedWriter.Write([]byte("대한민국"))
		if err != nil {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: Write error: %v\n", err)
			os.Exit(1)
		}

		expected := []byte{0xB4, 0xEB, 0xC7, 0xD1, 0xB9, 0xCE, 0xB1, 0xB9}
		if !bytes.Equal(buf.Bytes(), expected) {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: got %x, expected %x\n", buf.Bytes(), expected)
			os.Exit(1)
		}
	}

	// Assertion 6: korean.EUCKR.NewDecoder replaces unmappable or malformed bytes with replacement character
	{
		// 0xFF 0xFF is not a valid EUC-KR lead/trail byte pair
		invalidBytes := []byte{0xFF, 0xFF}
		decoded, err := korean.EUCKR.NewDecoder().Bytes(invalidBytes)
		if err != nil {
			fmt.Fprintf(os.Stderr, "assertion 6 failed: unexpected error on invalid bytes: %v\n", err)
			os.Exit(1)
		}
		if !strings.ContainsRune(string(decoded), '\uFFFD') {
			fmt.Fprintf(os.Stderr, "assertion 6 failed: replacement rune not found in %q\n", string(decoded))
			os.Exit(1)
		}
	}

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