golang.org/x/term v0.22.0: GetSize, GetState, IsTerminal

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 pkg:golang/golang.org/x/term@v0.22.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/golang.org/x/term@v0.22.0

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_test

import (
	"bytes"
	"os"
	"strings"
	"testing"

	"golang.org/x/term"
)

type bufferRW struct {
	in  *bytes.Buffer
	out *bytes.Buffer
}

func (rw *bufferRW) Read(p []byte) (n int, err error) {
	return rw.in.Read(p)
}

func (rw *bufferRW) Write(p []byte) (n int, err error) {
	return rw.out.Write(p)
}

func newBufferRW(input string) *bufferRW {
	return &bufferRW{
		in:  bytes.NewBufferString(input),
		out: &bytes.Buffer{},
	}
}

func TestIsTerminal(t *testing.T) {
	// Invalid file descriptor
	if term.IsTerminal(-1) {
		t.Fatal("expected IsTerminal(-1) to be false")
	}

	// Pipe file descriptor is not a terminal
	r, w, err := os.Pipe()
	if err != nil {
		t.Fatalf("failed to create pipe: %v", err)
	}
	defer r.Close()
	defer w.Close()

	if term.IsTerminal(int(r.Fd())) {
		t.Fatal("expected pipe reader to not be a terminal")
	}
	if term.IsTerminal(int(w.Fd())) {
		t.Fatal("expected pipe writer to not be a terminal")
	}
}

func TestGetSize(t *testing.T) {
	// Querying terminal size on non-terminal fd returns error
	r, w, err := os.Pipe()
	if err != nil {
		t.Fatalf("failed to create pipe: %v", err)
	}
	defer r.Close()
	defer w.Close()

	width, height, err := term.GetSize(int(r.Fd()))
	if err == nil {
		t.Fatalf("expected error querying size on non-terminal pipe, got width=%d, height=%d", width, height)
	}

	// Querying terminal size on invalid fd returns error
	_, _, err = term.GetSize(-1)
	if err == nil {
		t.Fatal("expected error querying size on invalid fd")
	}
}

func TestGetState(t *testing.T) {
	// Querying terminal state on non-terminal fd returns error
	r, w, err := os.Pipe()
	if err != nil {
		t.Fatalf("failed to create pipe: %v", err)
	}
	defer r.Close()
	defer w.Close()

	state, err := term.GetState(int(r.Fd()))
	if err == nil {
		t.Fatalf("expected error getting state on non-terminal pipe, got state=%v", state)
	}

	// Querying terminal state on invalid fd returns error
	_, err = term.GetState(-1)
	if err == nil {
		t.Fatal("expected error getting state on invalid fd")
	}
}

func TestMakeRawAndRestore(t *testing.T) {
	// Calling MakeRaw on non-terminal fd returns error
	r, w, err := os.Pipe()
	if err != nil {
		t.Fatalf("failed to create pipe: %v", err)
	}
	defer r.Close()
	defer w.Close()

	state, err := term.MakeRaw(int(r.Fd()))
	if err == nil {
		t.Fatalf("expected error making raw on non-terminal pipe, got state=%v", state)
	}

	// Calling Restore on non-terminal fd with dummy state returns error
	dummyState := &term.State{}
	err = term.Restore(int(r.Fd()), dummyState)
	if err == nil {
		t.Fatal("expected error restoring state on non-terminal pipe")
	}

	// Calling MakeRaw on invalid fd returns error
	_, err = term.MakeRaw(-1)
	if err == nil {
		t.Fatal("expected error making raw on invalid fd")
	}

	// Calling Restore on invalid fd returns error
	err = term.Restore(-1, dummyState)
	if err == nil {
		t.Fatal("expected error restoring state on invalid fd")
	}
}

func TestNewTerminal(t *testing.T) {
	rw := newBufferRW("echo test\r\n")
	terminal := term.NewTerminal(rw, "user$ ")

	// Test SetSize
	if err := terminal.SetSize(80, 24); err != nil {
		t.Fatalf("SetSize failed: %v", err)
	}

	// Test ReadLine
	line, err := terminal.ReadLine()
	if err != nil {
		t.Fatalf("ReadLine failed: %v", err)
	}
	if line != "echo test" {
		t.Fatalf("expected 'echo test', got '%s'", line)
	}
	if !strings.Contains(rw.out.String(), "user$ ") {
		t.Fatalf("expected prompt 'user$ ' in output, got '%s'", rw.out.String())
	}

	// Test SetPrompt
	terminal.SetPrompt("new$ ")
	rw.in.WriteString("next cmd\r\n")
	line2, err := terminal.ReadLine()
	if err != nil || line2 != "next cmd" {
		t.Fatalf("ReadLine after SetPrompt failed: line=%s, err=%v", line2, err)
	}
	if !strings.Contains(rw.out.String(), "new$ ") {
		t.Fatalf("expected updated prompt 'new$ ' in output, got '%s'", rw.out.String())
	}

	// Test Write
	n, err := terminal.Write([]byte("response\n"))
	if err != nil {
		t.Fatalf("Write failed: %v", err)
	}
	if n != 9 {
		t.Fatalf("expected 9 bytes written, got %d", n)
	}
	if !strings.Contains(rw.out.String(), "response\r\n") {
		t.Fatalf("expected newline translation to CRLF in output, got %q", rw.out.String())
	}
}

{"case":{"caseId":"case:sha256:7d0407387d506649e24a33480a8447c11413a814cd775485fd60def84e7e7f62","contract":["term.IsTerminal reports whether the given file descriptor is a terminal","term.GetSize returns error when querying dimensions of a non-terminal file descriptor","term.GetState returns error when querying state of a non-terminal file descriptor","term.MakeRaw returns error when configuring a non-terminal file descriptor into raw mode","term.Restore returns error when restoring terminal state on a non-terminal file descriptor","term.NewTerminal initializes a VT100 terminal handler over an io.ReadWriter"],"goal":"verify pkg:golang/golang.org/x/term@v0.22.0","kind":"HOW","packages":["pkg:golang/golang.org/x/term@v0.22.0"],"schemaVersion":1,"symbols":["golang.org/x/term.GetSize","golang.org/x/term.GetState","golang.org/x/term.IsTerminal","golang.org/x/term.MakeRaw","golang.org/x/term.NewTerminal","golang.org/x/term.Restore"]},"contractCommand":["go","test","-v","./..."],"environment":{"arch":"x64","distro":"ubuntu","ecosystem":"golang","language":"go","languageVersion":"1.26.6","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/term@v0.22.0"],"schemaVersion":1,"subject":"pkg:golang/golang.org/x/term@v0.22.0","symbols":["golang.org/x/term.GetSize","golang.org/x/term.GetState","golang.org/x/term.IsTerminal","golang.org/x/term.MakeRaw","golang.org/x/term.NewTerminal","golang.org/x/term.Restore"],"verifierAdapter":"golang@1"}

module sample

go 1.26.6

require (
	golang.org/x/sys v0.22.0 // indirect
	golang.org/x/term v0.22.0 // indirect
)

golang.org/x/sys v0.22.0 h1:RI27ohtqKCnwULzJLqkv897zojh5/DwS/ENaMzUOaWI=
golang.org/x/sys v0.22.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
golang.org/x/term v0.22.0 h1:BbsgPEJULsl2fV/AT3v15Mjva5yXKQDyKf+TbDz7QJk=
golang.org/x/term v0.22.0/go.mod h1:F3qCibpT5AMpCRfhfT53vVJwhLtIVHhB9XDjfFvnMI4=

{
  "schemaVersion": 1,
  "goal": "verify pkg:golang/golang.org/x/term@v0.22.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/golang.org/x/term@v0.22.0"
  ]
}