github.com/klauspost/compress v1.19.1: zlib.Resetter

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/zlib.Resetter in pkg:golang/github.com/klauspost/compress@v1.19.1
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/klauspost/compress@v1.19.1
Demonstrate these symbols/APIs:
  - github.com/klauspost/compress/zlib.Resetter

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:5869e8db73e7ae1b018db59cd28f158c94468a4f953edda2a0e2717c41d6a18a","contract":["io.ReadCloser returned by zlib.NewReader implements zlib.Resetter","Reset resets reader to decompress a new stream without dictionary","Reset allows reusing the same reader across multiple sequential streams","Reset with dictionary decompresses stream encoded with NewWriterLevelDict","Reset with corrupt stream returns error on reset or read","Reset with incorrect dictionary fails to decompress or verify checksum"],"goal":"verify github.com/klauspost/compress/zlib.Resetter in pkg:golang/github.com/klauspost/compress@v1.19.1","kind":"HOW","packages":["pkg:golang/github.com/klauspost/compress@v1.19.1"],"schemaVersion":1,"symbols":["github.com/klauspost/compress/zlib.Resetter"]},"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.19.1"],"schemaVersion":1,"subject":"pkg:golang/github.com/klauspost/compress@v1.19.1","symbols":["github.com/klauspost/compress/zlib.Resetter"],"verifierAdapter":"golang@1"}

module sample

go 1.26.6

require github.com/klauspost/compress v1.19.1

github.com/klauspost/compress v1.19.1 h1:VsB4HPswih7mmZ8WleSFQ75c/Ui1M4trX5oAsJnhSlk=
github.com/klauspost/compress v1.19.1/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=

package main

import (
	"bytes"
	"fmt"
	"io"
	"log"

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

func compressData(data []byte, dict []byte) ([]byte, error) {
	var buf bytes.Buffer
	var w *zlib.Writer
	var err error
	if dict != nil {
		w, err = zlib.NewWriterLevelDict(&buf, zlib.DefaultCompression, dict)
	} else {
		w = zlib.NewWriter(&buf)
	}
	if err != nil {
		return nil, err
	}
	if _, err := w.Write(data); err != nil {
		return nil, err
	}
	if err := w.Close(); err != nil {
		return nil, err
	}
	return buf.Bytes(), nil
}

func main() {
	msg1 := []byte("Hello, klauspost/compress zlib!")
	msg2 := []byte("Reusing reader instance using Resetter interface.")

	compressed1, err := compressData(msg1, nil)
	if err != nil {
		log.Fatalf("failed to compress msg1: %v", err)
	}

	compressed2, err := compressData(msg2, nil)
	if err != nil {
		log.Fatalf("failed to compress msg2: %v", err)
	}

	// 1. Initialize zlib Reader on stream 1
	r, err := zlib.NewReader(bytes.NewReader(compressed1))
	if err != nil {
		log.Fatalf("failed to create reader: %v", err)
	}
	defer r.Close()

	out1, err := io.ReadAll(r)
	if err != nil {
		log.Fatalf("failed to read stream 1: %v", err)
	}
	fmt.Printf("Stream 1: %s\n", out1)

	// 2. Type-assert to zlib.Resetter to reuse reader on stream 2
	resetter, ok := r.(zlib.Resetter)
	if !ok {
		log.Fatalf("reader does not implement zlib.Resetter")
	}

	if err := resetter.Reset(bytes.NewReader(compressed2), nil); err != nil {
		log.Fatalf("failed to reset reader: %v", err)
	}

	out2, err := io.ReadAll(r)
	if err != nil {
		log.Fatalf("failed to read stream 2: %v", err)
	}
	fmt.Printf("Stream 2: %s\n", out2)

	fmt.Println("Reader successfully reused via zlib.Resetter!")
}

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

package main

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

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

func compressWithDict(data []byte, dict []byte) ([]byte, error) {
	var buf bytes.Buffer
	var w *zlib.Writer
	var err error
	if dict != nil {
		w, err = zlib.NewWriterLevelDict(&buf, zlib.DefaultCompression, dict)
	} else {
		w = zlib.NewWriter(&buf)
	}
	if err != nil {
		return nil, err
	}
	if _, err := w.Write(data); err != nil {
		return nil, err
	}
	if err := w.Close(); err != nil {
		return nil, err
	}
	return buf.Bytes(), nil
}

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

func runTests() error {
	// 1. io.ReadCloser returned by zlib.NewReader implements zlib.Resetter
	{
		dummy, err := compressWithDict([]byte("contract test 1"), nil)
		if err != nil {
			return fmt.Errorf("contract 1: failed to compress dummy data: %w", err)
		}
		r, err := zlib.NewReader(bytes.NewReader(dummy))
		if err != nil {
			return fmt.Errorf("contract 1: failed to create zlib reader: %w", err)
		}
		defer r.Close()

		resetter, ok := r.(zlib.Resetter)
		if !ok || resetter == nil {
			return fmt.Errorf("contract 1: reader does not implement zlib.Resetter")
		}
	}

	// 2. Reset resets reader to decompress a new stream without dictionary
	{
		msg1 := []byte("stream one data for test 2")
		msg2 := []byte("stream two replacement data for test 2")
		c1, err := compressWithDict(msg1, nil)
		if err != nil {
			return fmt.Errorf("contract 2: failed to compress msg1: %w", err)
		}
		c2, err := compressWithDict(msg2, nil)
		if err != nil {
			return fmt.Errorf("contract 2: failed to compress msg2: %w", err)
		}

		r, err := zlib.NewReader(bytes.NewReader(c1))
		if err != nil {
			return fmt.Errorf("contract 2: NewReader failed: %w", err)
		}
		defer r.Close()

		res1, err := io.ReadAll(r)
		if err != nil {
			return fmt.Errorf("contract 2: failed reading stream 1: %w", err)
		}
		if !bytes.Equal(res1, msg1) {
			return fmt.Errorf("contract 2: stream 1 mismatch: got %q, want %q", res1, msg1)
		}

		resetter := r.(zlib.Resetter)
		if err := resetter.Reset(bytes.NewReader(c2), nil); err != nil {
			return fmt.Errorf("contract 2: Reset failed: %w", err)
		}

		res2, err := io.ReadAll(r)
		if err != nil {
			return fmt.Errorf("contract 2: failed reading stream 2 after Reset: %w", err)
		}
		if !bytes.Equal(res2, msg2) {
			return fmt.Errorf("contract 2: stream 2 mismatch: got %q, want %q", res2, msg2)
		}
	}

	// 3. Reset allows reusing the same reader across multiple sequential streams
	{
		messages := [][]byte{
			[]byte("batch stream payload zero"),
			[]byte("batch stream payload one"),
			[]byte("batch stream payload two"),
			[]byte("batch stream payload three"),
			[]byte("batch stream payload four"),
		}

		firstCompressed, err := compressWithDict(messages[0], nil)
		if err != nil {
			return fmt.Errorf("contract 3: failed to compress first message: %w", err)
		}

		r, err := zlib.NewReader(bytes.NewReader(firstCompressed))
		if err != nil {
			return fmt.Errorf("contract 3: NewReader failed: %w", err)
		}
		defer r.Close()

		firstRead, err := io.ReadAll(r)
		if err != nil || !bytes.Equal(firstRead, messages[0]) {
			return fmt.Errorf("contract 3: initial read failed or mismatched")
		}

		resetter := r.(zlib.Resetter)
		for i := 1; i < len(messages); i++ {
			compressed, err := compressWithDict(messages[i], nil)
			if err != nil {
				return fmt.Errorf("contract 3: failed to compress message %d: %w", i, err)
			}
			if err := resetter.Reset(bytes.NewReader(compressed), nil); err != nil {
				return fmt.Errorf("contract 3: Reset on iteration %d failed: %w", i, err)
			}
			out, err := io.ReadAll(r)
			if err != nil {
				return fmt.Errorf("contract 3: ReadAll on iteration %d failed: %w", i, err)
			}
			if !bytes.Equal(out, messages[i]) {
				return fmt.Errorf("contract 3: message %d mismatch: got %q, want %q", i, out, messages[i])
			}
		}
	}

	// 4. Reset with dictionary decompresses stream encoded with NewWriterLevelDict
	{
		dict := []byte("custom-shared-compression-dictionary-data")
		msg := []byte("payload compressed using a pre-shared dictionary")

		compressedDict, err := compressWithDict(msg, dict)
		if err != nil {
			return fmt.Errorf("contract 4: failed to compress with dict: %w", err)
		}

		// Initial reader with no dict
		dummy, _ := compressWithDict([]byte("init"), nil)
		r, err := zlib.NewReader(bytes.NewReader(dummy))
		if err != nil {
			return fmt.Errorf("contract 4: NewReader failed: %w", err)
		}
		defer r.Close()

		if _, err := io.ReadAll(r); err != nil {
			return fmt.Errorf("contract 4: reading dummy failed: %w", err)
		}

		resetter := r.(zlib.Resetter)
		if err := resetter.Reset(bytes.NewReader(compressedDict), dict); err != nil {
			return fmt.Errorf("contract 4: Reset with dict failed: %w", err)
		}

		out, err := io.ReadAll(r)
		if err != nil {
			return fmt.Errorf("contract 4: ReadAll with dict failed: %w", err)
		}
		if !bytes.Equal(out, msg) {
			return fmt.Errorf("contract 4: data mismatch: got %q, want %q", out, msg)
		}
	}

	// 5. Reset with corrupt stream returns error on reset or read
	{
		dummy, _ := compressWithDict([]byte("init"), nil)
		r, err := zlib.NewReader(bytes.NewReader(dummy))
		if err != nil {
			return fmt.Errorf("contract 5: NewReader failed: %w", err)
		}
		defer r.Close()

		resetter := r.(zlib.Resetter)
		corruptData := []byte{0x00, 0x00, 0x00, 0x00}
		resetErr := resetter.Reset(bytes.NewReader(corruptData), nil)
		if resetErr == nil {
			_, readErr := io.ReadAll(r)
			if readErr == nil {
				return fmt.Errorf("contract 5: expected error when reading corrupt zlib stream, got nil")
			}
		}
	}

	// 6. Reset with incorrect dictionary fails to decompress or verify checksum
	{
		dictA := []byte("dictionary-alpha-123456789")
		dictB := []byte("dictionary-beta-987654321")
		msg := []byte("dictionary mismatch contract test payload")

		compressedA, err := compressWithDict(msg, dictA)
		if err != nil {
			return fmt.Errorf("contract 6: failed to compress with dictA: %w", err)
		}

		dummy, _ := compressWithDict([]byte("init"), nil)
		r, err := zlib.NewReader(bytes.NewReader(dummy))
		if err != nil {
			return fmt.Errorf("contract 6: NewReader failed: %w", err)
		}
		defer r.Close()

		resetter := r.(zlib.Resetter)
		resetErr := resetter.Reset(bytes.NewReader(compressedA), dictB)
		if resetErr == nil {
			_, readErr := io.ReadAll(r)
			if readErr == nil {
				return fmt.Errorf("contract 6: expected error when using wrong dictionary, got nil")
			}
		}
	}

	return nil
}