golang.org/x/mod v0.39.0: module.InvalidPathError

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/mod/module.InvalidPathError in pkg:golang/golang.org/x/mod@v0.39.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/golang.org/x/mod@v0.39.0
Demonstrate these symbols/APIs:
  - golang.org/x/mod/module.InvalidPathError

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:780dd921c893b9f6fa9fce48f2f439acf621301a1662408b534cf0dd99a0cea1","contract":["module.CheckPath returns *InvalidPathError with Kind \"module\" for invalid module path","module.CheckImportPath returns *InvalidPathError with Kind \"import\" for invalid import path","module.CheckFilePath returns *InvalidPathError with Kind \"file\" for invalid file path","module.InvalidPathError Error() returns formatted error message containing kind and path","module.InvalidPathError Unwrap() returns the underlying wrapped error"],"goal":"verify golang.org/x/mod/module.InvalidPathError in pkg:golang/golang.org/x/mod@v0.39.0","kind":"HOW","packages":["pkg:golang/golang.org/x/mod@v0.39.0"],"schemaVersion":1,"symbols":["golang.org/x/mod/module.InvalidPathError"]},"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/mod@v0.39.0"],"schemaVersion":1,"subject":"pkg:golang/golang.org/x/mod@v0.39.0","symbols":["golang.org/x/mod/module.InvalidPathError"],"verifierAdapter":"golang@1"}

module example.com/sample

go 1.26.0

require golang.org/x/mod v0.39.0

golang.org/x/mod v0.39.0 h1:UF5zwQdCRRUpHfyPwr7d4UrGiVeldIsogtzWVnczL74=
golang.org/x/mod v0.39.0/go.mod h1:bvIbwjQ0HUFFf5AKukeeYQG4ZBUG9yxQbR9aEweIwYY=

package main

import (
	"errors"
	"fmt"

	"golang.org/x/mod/module"
)

func main() {
	path := "example.com/my invalid module"
	err := module.CheckPath(path)
	if err != nil {
		var ipe *module.InvalidPathError
		if errors.As(err, &ipe) {
			fmt.Printf("Validation error for %s: %s (kind: %s)\n", ipe.Path, ipe.Err, ipe.Kind)
			fmt.Printf("Formatted message: %s\n", ipe.Error())
			return
		}
		fmt.Printf("Unexpected error: %v\n", err)
		return
	}
	fmt.Println("Module path is valid.")
}

{
  "schemaVersion": 1,
  "goal": "verify golang.org/x/mod/module.InvalidPathError in pkg:golang/golang.org/x/mod@v0.39.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/golang.org/x/mod@v0.39.0"
  ],
  "symbols": [
    "golang.org/x/mod/module.InvalidPathError"
  ]
}

package main

import (
	"errors"
	"fmt"
	"os"
	"strings"

	"golang.org/x/mod/module"
)

func main() {
	// 1. module.CheckPath returns *InvalidPathError with Kind "module" for invalid module path
	{
		err := module.CheckPath("example.com/invalid path")
		if err == nil {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: expected error for invalid module path\n")
			os.Exit(1)
		}
		var ipe *module.InvalidPathError
		if !errors.As(err, &ipe) {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: expected *module.InvalidPathError, got %T\n", err)
			os.Exit(1)
		}
		if ipe.Kind != "module" {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: expected Kind 'module', got %q\n", ipe.Kind)
			os.Exit(1)
		}
		if ipe.Path != "example.com/invalid path" {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: expected Path 'example.com/invalid path', got %q\n", ipe.Path)
			os.Exit(1)
		}
		if ipe.Err == nil {
			fmt.Fprintf(os.Stderr, "assertion 1 failed: expected non-nil Err\n")
			os.Exit(1)
		}
	}

	// 2. module.CheckImportPath returns *InvalidPathError with Kind "import" for invalid import path
	{
		err := module.CheckImportPath("example.com/../bar")
		if err == nil {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: expected error for invalid import path\n")
			os.Exit(1)
		}
		var ipe *module.InvalidPathError
		if !errors.As(err, &ipe) {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: expected *module.InvalidPathError, got %T\n", err)
			os.Exit(1)
		}
		if ipe.Kind != "import" {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: expected Kind 'import', got %q\n", ipe.Kind)
			os.Exit(1)
		}
		if ipe.Path != "example.com/../bar" {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: expected Path 'example.com/../bar', got %q\n", ipe.Path)
			os.Exit(1)
		}
		if ipe.Err == nil {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: expected non-nil Err\n")
			os.Exit(1)
		}
	}

	// 3. module.CheckFilePath returns *InvalidPathError with Kind "file" for invalid file path
	{
		err := module.CheckFilePath("foo/?/bar")
		if err == nil {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: expected error for invalid file path\n")
			os.Exit(1)
		}
		var ipe *module.InvalidPathError
		if !errors.As(err, &ipe) {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: expected *module.InvalidPathError, got %T\n", err)
			os.Exit(1)
		}
		if ipe.Kind != "file" {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: expected Kind 'file', got %q\n", ipe.Kind)
			os.Exit(1)
		}
		if ipe.Path != "foo/?/bar" {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: expected Path 'foo/?/bar', got %q\n", ipe.Path)
			os.Exit(1)
		}
		if ipe.Err == nil {
			fmt.Fprintf(os.Stderr, "assertion 3 failed: expected non-nil Err\n")
			os.Exit(1)
		}
	}

	// 4. module.InvalidPathError Error() returns formatted error message containing kind and path
	{
		ipe := &module.InvalidPathError{
			Kind: "module",
			Path: "example.com/test",
			Err:  errors.New("invalid character"),
		}
		msg := ipe.Error()
		if !strings.Contains(msg, "malformed module path") || !strings.Contains(msg, "\"example.com/test\"") || !strings.Contains(msg, "invalid character") {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: unexpected Error() message: %q\n", msg)
			os.Exit(1)
		}
	}

	// 5. module.InvalidPathError Unwrap() returns the underlying wrapped error
	{
		underlying := errors.New("underlying cause")
		ipe := &module.InvalidPathError{
			Kind: "import",
			Path: "bad/path",
			Err:  underlying,
		}
		if ipe.Unwrap() != underlying {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: Unwrap() did not return underlying error\n")
			os.Exit(1)
		}
		if !errors.Is(ipe, underlying) {
			fmt.Fprintf(os.Stderr, "assertion 5 failed: errors.Is did not match underlying error\n")
			os.Exit(1)
		}
	}

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