github.com/klauspost/compress v1.20.0: zlib.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 zlib.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:
  - zlib.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:7b7bfbe7dd0ae3966db5851d79a2538cef77acc84b976cb041f1155622c35585","contract":["zlib.NewReader decompresses deflate-compressed payload with zlib framing back to original data","zlib.NewReader returns zlib.ErrHeader when input header is corrupt or invalid","zlib.NewReader returns EOF error on empty input reader during header initialization","zlib.NewReader supports zlib.Resetter interface to decompress consecutive streams without reallocation"],"goal":"verify zlib.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":["zlib.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":["zlib.NewReader"],"verifierAdapter":"golang@1"}

module example.com/zlibsample

go 1.25

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=

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

package main

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

	zlibsample "example.com/zlibsample"
	"github.com/klauspost/compress/zlib"
)

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

	decompressed, err := zlibsample.Decompress(compressed)
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: decompression 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 zlib.NewReader
	r, err := zlib.NewReader(bytes.NewReader(compressed))
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: direct zlib.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 zlib.NewReader failed: %v\n", err)
		_ = r.Close()
		os.Exit(1)
	}
	if err := r.Close(); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: closing zlib reader failed: %v\n", err)
		os.Exit(1)
	}
	if !bytes.Equal(directDecompressed, original) {
		fmt.Fprintf(os.Stderr, "FAIL: direct zlib.NewReader mismatch: got %q, want %q\n", directDecompressed, original)
		os.Exit(1)
	}

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

	// Assertion 3: zlib.NewReader returns EOF error on empty input reader during header initialization
	_, err = zlib.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: zlib.NewReader supports zlib.Resetter interface to decompress consecutive streams without reallocation
	payloadA := []byte("First stream payload for reusable zlib reader")
	payloadB := []byte("Second distinct stream payload verifying zlib.Resetter reinitialization")

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

	zr, err := zlib.NewReader(bytes.NewReader(compA))
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: initial zlib.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)
	}

	resetter, ok := zr.(zlib.Resetter)
	if !ok {
		fmt.Fprintf(os.Stderr, "FAIL: zlib reader does not implement zlib.Resetter\n")
		_ = zr.Close()
		os.Exit(1)
	}
	if err := resetter.Reset(bytes.NewReader(compB), nil); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: resetter.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 zlib reader failed: %v\n", err)
		os.Exit(1)
	}

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

package zlibsample

import (
	"bytes"
	"fmt"
	"io"

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

// Compress compresses the input data using klauspost/compress/zlib.
func Compress(data []byte) ([]byte, error) {
	var buf bytes.Buffer
	w := zlib.NewWriter(&buf)
	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 zlib-compressed data using zlib.NewReader.
func Decompress(compressed []byte) ([]byte, error) {
	r, err := zlib.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 zlib.NewReader to create a decompression reader.
func NewReader(r io.Reader) (io.ReadCloser, error) {
	return zlib.NewReader(r)
}

// ResetReader reuses an existing reader instance via zlib.Resetter.
func ResetReader(zr io.ReadCloser, r io.Reader) error {
	resetter, ok := zr.(zlib.Resetter)
	if !ok {
		return fmt.Errorf("reader does not implement zlib.Resetter")
	}
	return resetter.Reset(r, nil)
}