github.com/klauspost/compress v1.20.0: zlib

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 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/zlib

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:e64ee7e31f6c4cf052c1faeeb65624f4d6565a7c56deaf21d9fb725d18eb7a2b","contract":["zlib.NewWriter compresses data stream and zlib.NewReader decompresses to restore exact original payload","zlib.NewWriterLevel compresses with specified compression level including BestSpeed and BestCompression","zlib.NewWriterLevelDict and zlib.NewReaderDict compress and decompress data using a preset dictionary","zlib.NewReader returns error when reading invalid or corrupted zlib stream","zlib.Writer and zlib.Resetter support stream reuse via Reset"],"goal":"verify github.com/klauspost/compress/zlib 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/zlib"]},"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/zlib"],"verifierAdapter":"golang@1"}

module example.com/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 main

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

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

func main() {
	original := []byte("Hello, CodeSampleX with klauspost/compress zlib!")

	var buf bytes.Buffer
	writer := zlib.NewWriter(&buf)
	if _, err := writer.Write(original); err != nil {
		log.Fatalf("failed to write compressed data: %v", err)
	}
	if err := writer.Close(); err != nil {
		log.Fatalf("failed to close zlib writer: %v", err)
	}

	reader, err := zlib.NewReader(&buf)
	if err != nil {
		log.Fatalf("failed to create zlib reader: %v", err)
	}
	defer reader.Close()

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

	fmt.Printf("Original:     %s\n", string(original))
	fmt.Printf("Decompressed: %s\n", string(decompressed))
}

{
  "schemaVersion": 1,
  "goal": "verify github.com/klauspost/compress/zlib 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/zlib"
  ]
}

package main

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

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

func main() {
	// 1. zlib.NewWriter compresses data stream and zlib.NewReader decompresses to restore exact original payload
	{
		original := []byte("CodeSampleX verification payload for github.com/klauspost/compress/zlib stream compression.")
		var buf bytes.Buffer
		zw := zlib.NewWriter(&buf)
		if _, err := zw.Write(original); err != nil {
			fmt.Fprintf(os.Stderr, "zlib.NewWriter Write failed: %v\n", err)
			os.Exit(1)
		}
		if err := zw.Close(); err != nil {
			fmt.Fprintf(os.Stderr, "zlib.NewWriter Close failed: %v\n", err)
			os.Exit(1)
		}

		zr, err := zlib.NewReader(&buf)
		if err != nil {
			fmt.Fprintf(os.Stderr, "zlib.NewReader failed: %v\n", err)
			os.Exit(1)
		}
		decompressed, err := io.ReadAll(zr)
		if err != nil {
			fmt.Fprintf(os.Stderr, "zlib.NewReader ReadAll failed: %v\n", err)
			os.Exit(1)
		}
		if err := zr.Close(); err != nil {
			fmt.Fprintf(os.Stderr, "zlib.NewReader Close failed: %v\n", err)
			os.Exit(1)
		}
		if !bytes.Equal(original, decompressed) {
			fmt.Fprintf(os.Stderr, "decompressed mismatch: got %q, want %q\n", string(decompressed), string(original))
			os.Exit(1)
		}
	}

	// 2. zlib.NewWriterLevel compresses with specified compression level including BestSpeed and BestCompression
	{
		sampleData := bytes.Repeat([]byte("Repetitive pattern verifying klauspost/compress/zlib compression levels. "), 40)
		levels := []int{
			zlib.NoCompression,
			zlib.BestSpeed,
			zlib.BestCompression,
			zlib.DefaultCompression,
			zlib.HuffmanOnly,
		}
		for _, level := range levels {
			var b bytes.Buffer
			zw, err := zlib.NewWriterLevel(&b, level)
			if err != nil {
				fmt.Fprintf(os.Stderr, "zlib.NewWriterLevel(%d) failed: %v\n", level, err)
				os.Exit(1)
			}
			if _, err := zw.Write(sampleData); err != nil {
				fmt.Fprintf(os.Stderr, "zlib write with level %d failed: %v\n", level, err)
				os.Exit(1)
			}
			if err := zw.Close(); err != nil {
				fmt.Fprintf(os.Stderr, "zlib close with level %d failed: %v\n", level, err)
				os.Exit(1)
			}

			zr, err := zlib.NewReader(&b)
			if err != nil {
				fmt.Fprintf(os.Stderr, "zlib.NewReader for level %d failed: %v\n", level, err)
				os.Exit(1)
			}
			decomp, err := io.ReadAll(zr)
			if err != nil {
				fmt.Fprintf(os.Stderr, "zlib read for level %d failed: %v\n", level, err)
				os.Exit(1)
			}
			if err := zr.Close(); err != nil {
				fmt.Fprintf(os.Stderr, "zlib reader close for level %d failed: %v\n", level, err)
				os.Exit(1)
			}
			if !bytes.Equal(sampleData, decomp) {
				fmt.Fprintf(os.Stderr, "level %d roundtrip mismatch\n", level)
				os.Exit(1)
			}
		}
	}

	// 3. zlib.NewWriterLevelDict and zlib.NewReaderDict compress and decompress data using a preset dictionary
	{
		dict := []byte("custom dictionary context containing common strings and prefixes ")
		payload := []byte("custom dictionary context containing common strings and prefixes and actual test data to compress")
		var b bytes.Buffer
		zw, err := zlib.NewWriterLevelDict(&b, zlib.DefaultCompression, dict)
		if err != nil {
			fmt.Fprintf(os.Stderr, "zlib.NewWriterLevelDict failed: %v\n", err)
			os.Exit(1)
		}
		if _, err := zw.Write(payload); err != nil {
			fmt.Fprintf(os.Stderr, "zlib write with dict failed: %v\n", err)
			os.Exit(1)
		}
		if err := zw.Close(); err != nil {
			fmt.Fprintf(os.Stderr, "zlib close with dict failed: %v\n", err)
			os.Exit(1)
		}

		zr, err := zlib.NewReaderDict(&b, dict)
		if err != nil {
			fmt.Fprintf(os.Stderr, "zlib.NewReaderDict failed: %v\n", err)
			os.Exit(1)
		}
		decomp, err := io.ReadAll(zr)
		if err != nil {
			fmt.Fprintf(os.Stderr, "zlib read with dict failed: %v\n", err)
			os.Exit(1)
		}
		if err := zr.Close(); err != nil {
			fmt.Fprintf(os.Stderr, "zlib reader close with dict failed: %v\n", err)
			os.Exit(1)
		}
		if !bytes.Equal(payload, decomp) {
			fmt.Fprintf(os.Stderr, "dict roundtrip mismatch\n")
			os.Exit(1)
		}
	}

	// 4. zlib.NewReader returns error when reading invalid or corrupted zlib stream
	{
		corrupted := []byte{0x00, 0x01, 0x02, 0x03, 0x04}
		zr, err := zlib.NewReader(bytes.NewReader(corrupted))
		if err == nil {
			// Some zlib readers only fail on Read, check both
			_, readErr := io.ReadAll(zr)
			_ = zr.Close()
			if readErr == nil {
				fmt.Fprintf(os.Stderr, "expected error reading corrupted zlib stream, got nil\n")
				os.Exit(1)
			}
		}
	}

	// 5. zlib.Writer and zlib.Resetter support stream reuse via Reset
	{
		var buf1 bytes.Buffer
		zw := zlib.NewWriter(&buf1)
		msg1 := []byte("first stream payload for reuse test")
		if _, err := zw.Write(msg1); err != nil {
			fmt.Fprintf(os.Stderr, "first write failed: %v\n", err)
			os.Exit(1)
		}
		if err := zw.Close(); err != nil {
			fmt.Fprintf(os.Stderr, "first close failed: %v\n", err)
			os.Exit(1)
		}

		var buf2 bytes.Buffer
		zw.Reset(&buf2)
		msg2 := []byte("second stream payload after writer reset")
		if _, err := zw.Write(msg2); err != nil {
			fmt.Fprintf(os.Stderr, "second write failed: %v\n", err)
			os.Exit(1)
		}
		if err := zw.Close(); err != nil {
			fmt.Fprintf(os.Stderr, "second close failed: %v\n", err)
			os.Exit(1)
		}

		zr, err := zlib.NewReader(&buf1)
		if err != nil {
			fmt.Fprintf(os.Stderr, "reading buf1 failed: %v\n", err)
			os.Exit(1)
		}
		read1, err := io.ReadAll(zr)
		if err != nil || !bytes.Equal(read1, msg1) {
			fmt.Fprintf(os.Stderr, "mismatch on read1: %v\n", err)
			os.Exit(1)
		}

		resetter, ok := zr.(zlib.Resetter)
		if !ok {
			fmt.Fprintf(os.Stderr, "zlib reader does not implement zlib.Resetter\n")
			os.Exit(1)
		}
		if err := resetter.Reset(&buf2, nil); err != nil {
			fmt.Fprintf(os.Stderr, "reader Reset failed: %v\n", err)
			os.Exit(1)
		}
		read2, err := io.ReadAll(zr)
		if err != nil || !bytes.Equal(read2, msg2) {
			fmt.Fprintf(os.Stderr, "mismatch on read2: %v\n", err)
			os.Exit(1)
		}
		if err := zr.Close(); err != nil {
			fmt.Fprintf(os.Stderr, "closing reset reader failed: %v\n", err)
			os.Exit(1)
		}
	}

	fmt.Println("All contract assertions passed.")
}