golang.org/x/sys v0.41.0

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/sys@v0.41.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/golang.org/x/sys@v0.41.0
Constraints:
  - executionContext: node
Required runtime conditions:
  - ecosystem: npm
  - language: javascript
  - moduleSystem: cjs
  - packageManager: npm@10.9.8
  - runtime: node@22.23.2

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:da5a5cf33e42d0254e87f3680b0e58e60c7610e8769086f39c837aaf98d7e291","contract":["unix.Uname retrieves system UTS information returning non-empty operating system name and machine architecture","unix.Statfs retrieves filesystem statistics for the current path returning positive total blocks and block size","unix.Getrlimit queries resource limits for open file descriptors returning valid non-zero soft and hard limit values","unix.Sysinfo retrieves kernel system metrics returning positive uptime and positive total RAM"],"goal":"verify pkg:golang/golang.org/x/sys@v0.41.0","kind":"HOW","packages":["pkg:golang/golang.org/x/sys@v0.41.0"],"schemaVersion":1},"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/golang.org/x/sys@v0.41.0"],"schemaVersion":1,"verifierAdapter":"golang@1"}

module example.com/sample

go 1.26.6

require golang.org/x/sys v0.41.0

golang.org/x/sys v0.41.0 h1:Ivj+2Cp/ylzLiEU89QhWblYnOE9zerudt9Ftecq2C6k=
golang.org/x/sys v0.41.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=

package main

import (
	"fmt"
	"os"

	"golang.org/x/sys/unix"
)

// GetSystemUname retrieves kernel and system architecture information.
func GetSystemUname() (unix.Utsname, error) {
	var uts unix.Utsname
	if err := unix.Uname(&uts); err != nil {
		return uts, fmt.Errorf("uname failed: %w", err)
	}
	return uts, nil
}

// GetFileSystemStats queries filesystem statistics for the given path.
func GetFileSystemStats(path string) (unix.Statfs_t, error) {
	var stat unix.Statfs_t
	if err := unix.Statfs(path, &stat); err != nil {
		return stat, fmt.Errorf("statfs failed: %w", err)
	}
	return stat, nil
}

// GetOpenFileLimit queries the current resource limits for open file descriptors.
func GetOpenFileLimit() (unix.Rlimit, error) {
	var rlim unix.Rlimit
	if err := unix.Getrlimit(unix.RLIMIT_NOFILE, &rlim); err != nil {
		return rlim, fmt.Errorf("getrlimit failed: %w", err)
	}
	return rlim, nil
}

// GetSystemInfo retrieves system statistics including uptime and total memory.
func GetSystemInfo() (unix.Sysinfo_t, error) {
	var si unix.Sysinfo_t
	if err := unix.Sysinfo(&si); err != nil {
		return si, fmt.Errorf("sysinfo failed: %w", err)
	}
	return si, nil
}

func charsToString(ca []byte) string {
	s := make([]byte, 0, len(ca))
	for _, c := range ca {
		if c == 0 {
			break
		}
		s = append(s, c)
	}
	return string(s)
}

func main() {
	// Demonstrate Uname
	uts, err := GetSystemUname()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error getting utsname: %v\n", err)
		os.Exit(1)
	}
	sysname := charsToString(uts.Sysname[:])
	machine := charsToString(uts.Machine[:])
	fmt.Printf("System: %s (%s)\n", sysname, machine)

	// Demonstrate Statfs
	stat, err := GetFileSystemStats(".")
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error getting statfs: %v\n", err)
		os.Exit(1)
	}
	fmt.Printf("Filesystem: total blocks=%d, free blocks=%d\n", stat.Blocks, stat.Bfree)

	// Demonstrate Getrlimit
	rlim, err := GetOpenFileLimit()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error getting rlimit: %v\n", err)
		os.Exit(1)
	}
	fmt.Printf("File descriptor limits: cur=%d, max=%d\n", rlim.Cur, rlim.Max)

	// Demonstrate Sysinfo
	si, err := GetSystemInfo()
	if err != nil {
		fmt.Fprintf(os.Stderr, "Error getting sysinfo: %v\n", err)
		os.Exit(1)
	}
	fmt.Printf("System uptime: %d seconds, total RAM: %d bytes\n", si.Uptime, si.Totalram)
}

{
  "schemaVersion": 1,
  "goal": "verify pkg:golang/golang.org/x/sys@v0.41.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/golang.org/x/sys@v0.41.0"
  ],
  "constraints": {
    "executionContext": "node"
  },
  "runtimeConditions": {
    "ecosystem": "npm",
    "language": "javascript",
    "moduleSystem": "cjs",
    "packageManager": "npm@10.9.8",
    "runtime": "node@22.23.2"
  }
}

package main

import (
	"fmt"
	"os"

	"golang.org/x/sys/unix"
)

func charsToString(ca []byte) string {
	s := make([]byte, 0, len(ca))
	for _, c := range ca {
		if c == 0 {
			break
		}
		s = append(s, c)
	}
	return string(s)
}

func main() {
	// Assertion 1: unix.Uname retrieves system UTS information returning non-empty operating system name and machine architecture
	var uts unix.Utsname
	if err := unix.Uname(&uts); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: unix.Uname failed: %v\n", err)
		os.Exit(1)
	}
	sysname := charsToString(uts.Sysname[:])
	machine := charsToString(uts.Machine[:])
	if len(sysname) == 0 || len(machine) == 0 {
		fmt.Fprintf(os.Stderr, "FAIL: unix.Uname returned empty sysname or machine: sysname=%q, machine=%q\n", sysname, machine)
		os.Exit(1)
	}

	// Assertion 2: unix.Statfs retrieves filesystem statistics for the current path returning positive total blocks and block size
	var stat unix.Statfs_t
	if err := unix.Statfs(".", &stat); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: unix.Statfs failed: %v\n", err)
		os.Exit(1)
	}
	if stat.Blocks <= 0 || stat.Bsize <= 0 {
		fmt.Fprintf(os.Stderr, "FAIL: unix.Statfs returned invalid block metrics: blocks=%d, bsize=%d\n", stat.Blocks, stat.Bsize)
		os.Exit(1)
	}

	// Assertion 3: unix.Getrlimit queries resource limits for open file descriptors returning valid non-zero soft and hard limit values
	var rlim unix.Rlimit
	if err := unix.Getrlimit(unix.RLIMIT_NOFILE, &rlim); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: unix.Getrlimit failed: %v\n", err)
		os.Exit(1)
	}
	if rlim.Cur == 0 || rlim.Max == 0 || rlim.Cur > rlim.Max {
		fmt.Fprintf(os.Stderr, "FAIL: unix.Getrlimit returned invalid rlimit values: cur=%d, max=%d\n", rlim.Cur, rlim.Max)
		os.Exit(1)
	}

	// Assertion 4: unix.Sysinfo retrieves kernel system metrics returning positive uptime and positive total RAM
	var si unix.Sysinfo_t
	if err := unix.Sysinfo(&si); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: unix.Sysinfo failed: %v\n", err)
		os.Exit(1)
	}
	if si.Uptime <= 0 || si.Totalram <= 0 {
		fmt.Fprintf(os.Stderr, "FAIL: unix.Sysinfo returned non-positive uptime or totalram: uptime=%d, totalram=%d\n", si.Uptime, si.Totalram)
		os.Exit(1)
	}

	fmt.Println("PASS: golang.org/x/sys contract passed")
}