github.com/klauspost/compress v1.20.0: flate.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 flate.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:
  - flate.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:e1eb927ebd06392087de1d026a924eae51fbac7adc35727c23342076f3bae52a","contract":["flate.NewReader decompresses standard DEFLATE streams and handles empty inputs","flate.NewReader reports read errors on corrupted or invalid DEFLATE streams","flate.NewReader returns a reader implementing flate.Resetter supporting stream reuse and custom dictionaries"],"goal":"verify flate.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":["flate.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":["flate.NewReader"],"verifierAdapter":"golang@1"}

package flatereader

import (
	"bytes"
	"fmt"
	"io"

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

// Decompress reads and decompresses DEFLATE-encoded data using flate.NewReader.
func Decompress(compressed []byte) ([]byte, error) {
	reader := flate.NewReader(bytes.NewReader(compressed))
	defer reader.Close()

	decompressed, err := io.ReadAll(reader)
	if err != nil {
		return nil, fmt.Errorf("decompress failed: %w", err)
	}
	return decompressed, nil
}

// ResettableDecompressor wraps a flate reader and reuses it across multiple streams via Resetter.
type ResettableDecompressor struct {
	reader io.ReadCloser
}

// NewResettableDecompressor creates a decompressor initialized with an initial stream.
func NewResettableDecompressor(initial []byte) (*ResettableDecompressor, error) {
	r := flate.NewReader(bytes.NewReader(initial))
	return &ResettableDecompressor{reader: r}, nil
}

// DecompressAndReset decodes the given compressed data reusing the internal reader with dict.
func (d *ResettableDecompressor) DecompressAndReset(compressed []byte, dict []byte) ([]byte, error) {
	if resetter, ok := d.reader.(flate.Resetter); ok {
		if err := resetter.Reset(bytes.NewReader(compressed), dict); err != nil {
			return nil, fmt.Errorf("reset failed: %w", err)
		}
	} else {
		return nil, fmt.Errorf("reader does not implement flate.Resetter")
	}

	decompressed, err := io.ReadAll(d.reader)
	if err != nil {
		return nil, fmt.Errorf("read failed: %w", err)
	}
	return decompressed, nil
}

// Close releases any resources associated with the underlying reader.
func (d *ResettableDecompressor) Close() error {
	if d.reader != nil {
		return d.reader.Close()
	}
	return nil
}

module example.com/flate-sample

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 flate.NewReader in pkg:golang/github.com/klauspost/compress@v1.20.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/klauspost/compress@v1.20.0"
  ],
  "symbols": [
    "flate.NewReader"
  ]
}

package main

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

	flatereader "example.com/flate-sample"
	"github.com/klauspost/compress/flate"
)

func compressData(src []byte, level int) ([]byte, error) {
	var buf bytes.Buffer
	w, err := flate.NewWriter(&buf, level)
	if err != nil {
		return nil, err
	}
	if _, err := w.Write(src); err != nil {
		return nil, err
	}
	if err := w.Close(); err != nil {
		return nil, err
	}
	return buf.Bytes(), nil
}

func compressWithDict(src []byte, level int, dict []byte) ([]byte, error) {
	var buf bytes.Buffer
	w, err := flate.NewWriterDict(&buf, level, dict)
	if err != nil {
		return nil, err
	}
	if _, err := w.Write(src); err != nil {
		return nil, err
	}
	if err := w.Close(); err != nil {
		return nil, err
	}
	return buf.Bytes(), nil
}

func main() {
	// Assertion 1: flate.NewReader decompresses standard DEFLATE streams to original content
	originalText := []byte("The quick brown fox jumps over the lazy dog. Repetition improves compression ratio. 1234567890!")
	compressed, err := compressData(originalText, flate.DefaultCompression)
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: compression helper failed: %v\n", err)
		os.Exit(1)
	}

	decompressed, err := flatereader.Decompress(compressed)
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: Decompress via flate.NewReader failed: %v\n", err)
		os.Exit(1)
	}
	if !bytes.Equal(decompressed, originalText) {
		fmt.Fprintf(os.Stderr, "FAIL: decompressed output mismatch. expected %q, got %q\n", string(originalText), string(decompressed))
		os.Exit(1)
	}

	// Assertion 2: Direct flate.NewReader handles empty and multi-block payloads
	emptyData := []byte{}
	compressedEmpty, err := compressData(emptyData, flate.DefaultCompression)
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: compressing empty data failed: %v\n", err)
		os.Exit(1)
	}
	emptyReader := flate.NewReader(bytes.NewReader(compressedEmpty))
	readEmpty, err := io.ReadAll(emptyReader)
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: reading empty stream failed: %v\n", err)
		os.Exit(1)
	}
	if err := emptyReader.Close(); err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: closing empty reader failed: %v\n", err)
		os.Exit(1)
	}
	if len(readEmpty) != 0 {
		fmt.Fprintf(os.Stderr, "FAIL: expected 0 bytes for empty stream, got %d\n", len(readEmpty))
		os.Exit(1)
	}

	// Assertion 3: flate.NewReader returns error when reading invalid/corrupted stream
	corrupted := []byte{0xFF, 0xFE, 0xFD, 0xFC, 0xFB, 0xFA, 0xF9, 0xF8}
	badReader := flate.NewReader(bytes.NewReader(corrupted))
	_, badErr := io.ReadAll(badReader)
	if badErr == nil {
		fmt.Fprintf(os.Stderr, "FAIL: expected error on corrupted stream, got nil\n")
		os.Exit(1)
	}
	_ = badReader.Close()

	// Assertion 4: flate.NewReader returns reader implementing flate.Resetter for reuse
	stream1Text := []byte("First stream payload to verify flate reader initialization")
	stream2Text := []byte("Second stream payload to verify flate reader reset and reuse")
	comp1, err := compressData(stream1Text, flate.BestSpeed)
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: compressing stream 1 failed: %v\n", err)
		os.Exit(1)
	}
	comp2, err := compressData(stream2Text, flate.BestSpeed)
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: compressing stream 2 failed: %v\n", err)
		os.Exit(1)
	}

	decompressor, err := flatereader.NewResettableDecompressor(comp1)
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: NewResettableDecompressor failed: %v\n", err)
		os.Exit(1)
	}
	defer decompressor.Close()

	// Read initial stream
	out1, err := flatereader.Decompress(comp1)
	if err != nil || !bytes.Equal(out1, stream1Text) {
		fmt.Fprintf(os.Stderr, "FAIL: initial stream decode mismatch\n")
		os.Exit(1)
	}

	// Reset and read second stream
	out2, err := decompressor.DecompressAndReset(comp2, nil)
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: DecompressAndReset failed: %v\n", err)
		os.Exit(1)
	}
	if !bytes.Equal(out2, stream2Text) {
		fmt.Fprintf(os.Stderr, "FAIL: reset stream 2 output mismatch\n")
		os.Exit(1)
	}

	// Assertion 5: flate.NewReader with dictionary decompression via Resetter
	dict := []byte("common-dictionary-prefix-for-compression-testing")
	dictPayload := []byte("common-dictionary-prefix-for-compression-testing specific message body")
	compDict, err := compressWithDict(dictPayload, flate.DefaultCompression, dict)
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: compressing with dict failed: %v\n", err)
		os.Exit(1)
	}

	outDict, err := decompressor.DecompressAndReset(compDict, dict)
	if err != nil {
		fmt.Fprintf(os.Stderr, "FAIL: DecompressAndReset with dict failed: %v\n", err)
		os.Exit(1)
	}
	if !bytes.Equal(outDict, dictPayload) {
		fmt.Fprintf(os.Stderr, "FAIL: dictionary decompressed output mismatch\n")
		os.Exit(1)
	}

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