github.com/klauspost/compress v1.20.0: gzip.NewReader

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/klauspost/compress/gzip.NewReader in pkg:golang/github.com/klauspost/compress@v1.20.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/klauspost/compress@v1.20.0
Demonstrate these symbols/APIs:
  - github.com/klauspost/compress/gzip.NewReader

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:e1bb0b21a5aab3e0026d8380de7b2c59e518f7ca572fd614531fb38a9438f5f3","contract":["gzip.NewReader decompresses gzip-compressed payload back to original data","gzip.NewReader returns gzip.ErrHeader when input header is corrupt or invalid","gzip.NewReader returns EOF error on empty input reader during header initialization","gzip.Reader.Reset reuses reader instance to decompress consecutive streams without reallocation","gzip.Reader exposes header metadata from compressed stream"],"goal":"verify github.com/klauspost/compress/gzip.NewReader in pkg:golang/github.com/klauspost/compress@v1.20.0","kind":"HOW","packages":["pkg:golang/github.com/klauspost/compress@v1.20.0"],"schemaVersion":1,"symbols":["github.com/klauspost/compress/gzip.NewReader"]},"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/github.com/klauspost/compress@v1.20.0"],"schemaVersion":1,"subject":"pkg:golang/github.com/klauspost/compress@v1.20.0","symbols":["github.com/klauspost/compress/gzip.NewReader"],"verifierAdapter":"golang@1"}

module sample

go 1.26.6

require github.com/klauspost/compress v1.20.0

github.com/klauspost/compress v1.20.0 h1:a3C1ke2ohxFymNlb2HWAHjDeKCI90scRskErZkR0ezA=
github.com/klauspost/compress v1.20.0/go.mod h1:LUdAzn7YLVvxLpc7y3V1m40wESHTgc1422pwwBSKYuI=

package sample

import (
	"bytes"
	"fmt"
	"io"
	"time"

	"github.com/klauspost/compress/gzip"
)

// Compress compresses data using klauspost/compress/gzip and optional filename header.
func Compress(data []byte, filename string) ([]byte, error) {
	var buf bytes.Buffer
	w := gzip.NewWriter(&buf)
	if filename != "" {
		w.Name = filename
		w.ModTime = time.Unix(1700000000, 0).UTC()
	}
	if _, err := w.Write(data); err != nil {
		_ = w.Close()
		return nil, fmt.Errorf("compress write: %w", err)
	}
	if err := w.Close(); err != nil {
		return nil, fmt.Errorf("compress close: %w", err)
	}
	return buf.Bytes(), nil
}

// Decompress decompresses gzip-compressed data using gzip.NewReader.
func Decompress(compressed []byte) ([]byte, error) {
	r, err := gzip.NewReader(bytes.NewReader(compressed))
	if err != nil {
		return nil, err
	}
	defer r.Close()

	out, err := io.ReadAll(r)
	if err != nil {
		return nil, fmt.Errorf("decompress read: %w", err)
	}
	return out, nil
}

// NewReader wraps gzip.NewReader to create a decompression reader.
func NewReader(r io.Reader) (*gzip.Reader, error) {
	return gzip.NewReader(r)
}

// ResetReader reuses an existing gzip.Reader instance via Reader.Reset.
func ResetReader(zr *gzip.Reader, r io.Reader) error {
	return zr.Reset(r)
}

{
  "schemaVersion": 1,
  "goal": "verify github.com/klauspost/compress/gzip.NewReader in pkg:golang/github.com/klauspost/compress@v1.20.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/klauspost/compress@v1.20.0"
  ],
  "symbols": [
    "github.com/klauspost/compress/gzip.NewReader"
  ]
}

package main

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

	"github.com/klauspost/compress/gzip"
	"sample"
)

func main() {
	// Assertion 1: gzip.NewReader decompresses gzip-compressed payload back to original data
	original := []byte("The quick brown fox jumps over the lazy dog - klauspost/compress/gzip contract payload")
	compressed, err := sample.Compress(original, "")
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: helper Compress failed: %v\n", err)
		os.Exit(1)
	}

	decompressed, err := sample.Decompress(compressed)
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: helper Decompress failed: %v\n", err)
		os.Exit(1)
	}
	if !bytes.Equal(decompressed, original) {
		fmt.Fprintf(os.Stderr, "FAIL: decompressed bytes do not match original: got %q, want %q\n", decompressed, original)
		os.Exit(1)
	}

	// Direct verification with gzip.NewReader
	r, err := gzip.NewReader(bytes.NewReader(compressed))
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: direct gzip.NewReader returned error: %v\n", err)
		os.Exit(1)
	}
	directDecompressed, err := io.ReadAll(r)
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: io.ReadAll from gzip.NewReader failed: %v\n", err)
		_ = r.Close()
		os.Exit(1)
	}
	if err := r.Close(); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: closing gzip reader failed: %v\n", err)
		os.Exit(1)
	}
	if !bytes.Equal(directDecompressed, original) {
		fmt.Fprintf(os.Stderr, "FAIL: direct gzip.NewReader mismatch: got %q, want %q\n", directDecompressed, original)
		os.Exit(1)
	}

	// Assertion 2: gzip.NewReader returns gzip.ErrHeader when input header is corrupt or invalid
	invalidData := []byte{0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99}
	_, err = gzip.NewReader(bytes.NewReader(invalidData))
	if err == nil {
		fmt.Fprintf(os.Stderr, "FAIL: expected gzip.ErrHeader for invalid data, got nil error\n")
		os.Exit(1)
	}
	if !errors.Is(err, gzip.ErrHeader) {
		fmt.Fprintf(os.Stderr, "FAIL: expected errors.Is(err, gzip.ErrHeader), got %v\n", err)
		os.Exit(1)
	}

	// Assertion 3: gzip.NewReader returns EOF error on empty input reader during header initialization
	_, err = gzip.NewReader(bytes.NewReader([]byte{}))
	if err == nil {
		fmt.Fprintf(os.Stderr, "FAIL: expected EOF on empty input reader, got nil error\n")
		os.Exit(1)
	}
	if !errors.Is(err, io.EOF) && !errors.Is(err, io.ErrUnexpectedEOF) {
		fmt.Fprintf(os.Stderr, "FAIL: expected EOF or ErrUnexpectedEOF on empty reader, got %v\n", err)
		os.Exit(1)
	}

	// Assertion 4: gzip.Reader.Reset reuses reader instance to decompress consecutive streams without reallocation
	payloadA := []byte("First stream payload for reusable gzip reader")
	payloadB := []byte("Second distinct stream payload verifying gzip.Reader.Reset reinitialization")

	compA, err := sample.Compress(payloadA, "")
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: compress payloadA failed: %v\n", err)
		os.Exit(1)
	}
	compB, err := sample.Compress(payloadB, "")
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: compress payloadB failed: %v\n", err)
		os.Exit(1)
	}

	zr, err := gzip.NewReader(bytes.NewReader(compA))
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: initial gzip.NewReader for payloadA failed: %v\n", err)
		os.Exit(1)
	}
	outA, err := io.ReadAll(zr)
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: read payloadA failed: %v\n", err)
		_ = zr.Close()
		os.Exit(1)
	}
	if !bytes.Equal(outA, payloadA) {
		fmt.Fprintf(os.Stderr, "FAIL: payloadA mismatch: got %q, want %q\n", outA, payloadA)
		_ = zr.Close()
		os.Exit(1)
	}

	if err := zr.Reset(bytes.NewReader(compB)); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: zr.Reset failed: %v\n", err)
		_ = zr.Close()
		os.Exit(1)
	}
	outB, err := io.ReadAll(zr)
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: read payloadB failed: %v\n", err)
		_ = zr.Close()
		os.Exit(1)
	}
	if !bytes.Equal(outB, payloadB) {
		fmt.Fprintf(os.Stderr, "FAIL: payloadB mismatch: got %q, want %q\n", outB, payloadB)
		_ = zr.Close()
		os.Exit(1)
	}
	if err := zr.Close(); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: closing reset gzip reader failed: %v\n", err)
		os.Exit(1)
	}

	// Assertion 5: gzip.Reader exposes header metadata from compressed stream
	testFileName := "contract_test_file.txt"
	compWithHeader, err := sample.Compress(original, testFileName)
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: compress with header failed: %v\n", err)
		os.Exit(1)
	}

	hr, err := gzip.NewReader(bytes.NewReader(compWithHeader))
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: gzip.NewReader with header failed: %v\n", err)
		os.Exit(1)
	}
	if hr.Header.Name != testFileName {
		fmt.Fprintf(os.Stderr, "FAIL: expected header name %q, got %q\n", testFileName, hr.Header.Name)
		_ = hr.Close()
		os.Exit(1)
	}
	if hr.Header.ModTime.Unix() != 1700000000 {
		fmt.Fprintf(os.Stderr, "FAIL: expected header mod time 1700000000, got %d\n", hr.Header.ModTime.Unix())
		_ = hr.Close()
		os.Exit(1)
	}
	if err := hr.Close(); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: closing hr reader failed: %v\n", err)
		os.Exit(1)
	}

	fmt.Println("PASS: gzip.NewReader contract passed")
}