github.com/spf13/afero v1.15.0: NewMemMapFs

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 github.com/spf13/afero.NewMemMapFs in pkg:golang/github.com/spf13/afero@v1.15.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/spf13/afero@v1.15.0
Demonstrate these symbols/APIs:
  - github.com/spf13/afero.NewMemMapFs

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:9e27f68ee28c30f1e9ead4640a8b013c9f8b8e63efe5279f41b15ed91c9f0d9b","contract":["NewMemMapFs initializes an in-memory filesystem implementing afero.Fs interface","Name returns MemMapFS as filesystem identifier","Create creates an in-memory file that can be written to and read from","MkdirAll creates nested directory hierarchies in the memory filesystem","Stat reports correct file size and attributes for created paths","Remove deletes a file and subsequent Open returns os.ErrNotExist","Rename moves a file to a new location preserving its content","OpenFile with os.O_APPEND appends data to an existing file","Chtimes updates modification time of in-memory file"],"goal":"verify github.com/spf13/afero.NewMemMapFs in pkg:golang/github.com/spf13/afero@v1.15.0","kind":"HOW","packages":["pkg:golang/github.com/spf13/afero@v1.15.0"],"schemaVersion":1,"symbols":["github.com/spf13/afero.NewMemMapFs"]},"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/github.com/spf13/afero@v1.15.0"],"schemaVersion":1,"subject":"pkg:golang/github.com/spf13/afero@v1.15.0","symbols":["github.com/spf13/afero.NewMemMapFs"],"verifierAdapter":"golang@1"}

module example.com/sample

go 1.26.6

require github.com/spf13/afero v1.15.0

require golang.org/x/text v0.28.0 // indirect

github.com/spf13/afero v1.15.0 h1:b/YBCLWAJdFWJTN9cLhiXXcD7mzKn9Dm86dNnfyQw1I=
github.com/spf13/afero v1.15.0/go.mod h1:NC2ByUVxtQs4b3sIUphxK0NioZnmxgyCrfzeuq8lxMg=
golang.org/x/text v0.28.0 h1:rhazDwis8INMIwQ4tpjLDzUhx6RlXqZNPEM0huQojng=
golang.org/x/text v0.28.0/go.mod h1:U8nCwOR8jO/marOQ0QbDiOngZVEBB7MAiitBuMjXiNU=

package main

import (
	"fmt"
	"io"
	"log"

	"github.com/spf13/afero"
)

func main() {
	fs := afero.NewMemMapFs()
	fmt.Printf("Filesystem initialized: %s\n", fs.Name())

	filePath := "/data/example.txt"
	if err := fs.MkdirAll("/data", 0755); err != nil {
		log.Fatalf("failed to create directory: %v", err)
	}

	file, err := fs.Create(filePath)
	if err != nil {
		log.Fatalf("failed to create file: %v", err)
	}
	defer file.Close()

	payload := []byte("Hello from afero NewMemMapFs!")
	if _, err := file.Write(payload); err != nil {
		log.Fatalf("failed to write payload: %v", err)
	}

	readFile, err := fs.Open(filePath)
	if err != nil {
		log.Fatalf("failed to open file: %v", err)
	}
	defer readFile.Close()

	content, err := io.ReadAll(readFile)
	if err != nil {
		log.Fatalf("failed to read content: %v", err)
	}

	fmt.Printf("Read from %s: %s\n", filePath, string(content))
}

{
  "schemaVersion": 1,
  "goal": "verify github.com/spf13/afero.NewMemMapFs in pkg:golang/github.com/spf13/afero@v1.15.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/spf13/afero@v1.15.0"
  ],
  "symbols": [
    "github.com/spf13/afero.NewMemMapFs"
  ]
}

package main

import (
	"bytes"
	"errors"
	"fmt"
	"io"
	"os"
	"time"

	"github.com/spf13/afero"
)

func main() {
	if err := runContractTests(); err != nil {
		fmt.Fprintf(os.Stderr, "Contract test failed: %v\n", err)
		os.Exit(1)
	}
	fmt.Println("All afero NewMemMapFs contract assertions passed.")
}

func runContractTests() error {
	// 1. NewMemMapFs initializes an in-memory filesystem implementing afero.Fs interface
	var fs afero.Fs = afero.NewMemMapFs()
	if fs == nil {
		return fmt.Errorf("NewMemMapFs returned nil")
	}

	// 2. Name returns MemMapFS as filesystem identifier
	if name := fs.Name(); name != "MemMapFS" {
		return fmt.Errorf("expected filesystem name MemMapFS, got %q", name)
	}

	// 3. Create creates an in-memory file that can be written to and read from
	const testFile = "/file1.txt"
	testData := []byte("contract test payload 12345")
	f1, err := fs.Create(testFile)
	if err != nil {
		return fmt.Errorf("Create failed: %w", err)
	}
	if n, err := f1.Write(testData); err != nil || n != len(testData) {
		f1.Close()
		return fmt.Errorf("Write failed: wrote %d/%d bytes, err: %w", n, len(testData), err)
	}
	if err := f1.Close(); err != nil {
		return fmt.Errorf("Close failed: %w", err)
	}

	rFile, err := fs.Open(testFile)
	if err != nil {
		return fmt.Errorf("Open failed: %w", err)
	}
	readBack, err := io.ReadAll(rFile)
	rFile.Close()
	if err != nil {
		return fmt.Errorf("ReadAll failed: %w", err)
	}
	if !bytes.Equal(readBack, testData) {
		return fmt.Errorf("content mismatch: expected %q, got %q", string(testData), string(readBack))
	}

	// 4. MkdirAll creates nested directory hierarchies in the memory filesystem
	const dirPath = "/nested/dir/structure"
	if err := fs.MkdirAll(dirPath, 0755); err != nil {
		return fmt.Errorf("MkdirAll failed: %w", err)
	}
	dirInfo, err := fs.Stat(dirPath)
	if err != nil {
		return fmt.Errorf("Stat on created dir failed: %w", err)
	}
	if !dirInfo.IsDir() {
		return fmt.Errorf("expected %s to be a directory", dirPath)
	}

	// 5. Stat reports correct file size and attributes for created paths
	fInfo, err := fs.Stat(testFile)
	if err != nil {
		return fmt.Errorf("Stat failed: %w", err)
	}
	if fInfo.Size() != int64(len(testData)) {
		return fmt.Errorf("expected size %d, got %d", len(testData), fInfo.Size())
	}
	if fInfo.IsDir() {
		return fmt.Errorf("expected %s not to be a directory", testFile)
	}

	// 6. Remove deletes a file and subsequent Open returns os.ErrNotExist
	if err := fs.Remove(testFile); err != nil {
		return fmt.Errorf("Remove failed: %w", err)
	}
	if _, err := fs.Open(testFile); !errors.Is(err, os.ErrNotExist) {
		return fmt.Errorf("expected os.ErrNotExist after Remove, got %v", err)
	}

	// 7. Rename moves a file to a new location preserving its content
	const origPath = "/nested/dir/original.txt"
	const newPath = "/nested/dir/renamed.txt"
	origPayload := []byte("payload for rename test")
	fOrig, err := fs.Create(origPath)
	if err != nil {
		return fmt.Errorf("Create for rename failed: %w", err)
	}
	if _, err := fOrig.Write(origPayload); err != nil {
		fOrig.Close()
		return fmt.Errorf("Write for rename failed: %w", err)
	}
	fOrig.Close()

	if err := fs.Rename(origPath, newPath); err != nil {
		return fmt.Errorf("Rename failed: %w", err)
	}
	if _, err := fs.Open(origPath); !errors.Is(err, os.ErrNotExist) {
		return fmt.Errorf("expected original path to not exist after rename, got %v", err)
	}
	fRenamed, err := fs.Open(newPath)
	if err != nil {
		return fmt.Errorf("Open renamed file failed: %w", err)
	}
	renamedContent, err := io.ReadAll(fRenamed)
	fRenamed.Close()
	if err != nil {
		return fmt.Errorf("ReadAll on renamed file failed: %w", err)
	}
	if !bytes.Equal(renamedContent, origPayload) {
		return fmt.Errorf("renamed content mismatch: expected %q, got %q", string(origPayload), string(renamedContent))
	}

	// 8. OpenFile with os.O_APPEND appends data to an existing file
	appendFile, err := fs.OpenFile(newPath, os.O_WRONLY|os.O_APPEND, 0644)
	if err != nil {
		return fmt.Errorf("OpenFile for append failed: %w", err)
	}
	appendSuffix := []byte(" - appended data")
	if _, err := appendFile.Write(appendSuffix); err != nil {
		appendFile.Close()
		return fmt.Errorf("Write append failed: %w", err)
	}
	appendFile.Close()

	fAfterAppend, err := fs.Open(newPath)
	if err != nil {
		return fmt.Errorf("Open after append failed: %w", err)
	}
	afterAppendContent, err := io.ReadAll(fAfterAppend)
	fAfterAppend.Close()
	if err != nil {
		return fmt.Errorf("ReadAll after append failed: %w", err)
	}
	expectedAppended := append(origPayload, appendSuffix...)
	if !bytes.Equal(afterAppendContent, expectedAppended) {
		return fmt.Errorf("appended content mismatch: expected %q, got %q", string(expectedAppended), string(afterAppendContent))
	}

	// 9. Chtimes updates modification time of in-memory file
	newModTime := time.Date(2025, 1, 1, 12, 0, 0, 0, time.UTC)
	if err := fs.Chtimes(newPath, newModTime, newModTime); err != nil {
		return fmt.Errorf("Chtimes failed: %w", err)
	}
	chStat, err := fs.Stat(newPath)
	if err != nil {
		return fmt.Errorf("Stat after Chtimes failed: %w", err)
	}
	if !chStat.ModTime().Equal(newModTime) {
		return fmt.Errorf("expected ModTime %v, got %v", newModTime, chStat.ModTime())
	}

	return nil
}