github.com/klauspost/compress v1.20.0: flate.NewWriter

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/flate.NewWriter 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/flate.NewWriter

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:58aa45e6bb5743027d30952d259e902b0d8026049faea3ae098d240177e119cf","contract":["flate.NewWriter creates a compressor that compresses data at DefaultCompression (-1) and round-trips via flate.NewReader","flate.NewWriter supports compression levels from BestSpeed (1) to BestCompression (9)","flate.NewWriter supports NoCompression (0) and HuffmanOnly (-2) compression levels","flate.NewWriter rejects invalid compression levels outside [-2, 9] with a descriptive error","flate.Writer.Reset reinitializes an existing writer to target a new output stream"],"goal":"verify github.com/klauspost/compress/flate.NewWriter 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/flate.NewWriter"]},"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/flate.NewWriter"],"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 main

import (
	"bytes"
	"fmt"
	"io"

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

func main() {
	original := []byte("klauspost flate compression demonstration payload")

	var compressed bytes.Buffer
	writer, err := flate.NewWriter(&compressed, flate.DefaultCompression)
	if err != nil {
		panic(err)
	}

	if _, err := writer.Write(original); err != nil {
		panic(err)
	}
	if err := writer.Close(); err != nil {
		panic(err)
	}

	reader := flate.NewReader(&compressed)
	decompressed, err := io.ReadAll(reader)
	if err != nil {
		panic(err)
	}
	if err := reader.Close(); err != nil {
		panic(err)
	}

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

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

package main

import (
	"bytes"
	"fmt"
	"io"
	"strings"

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

func main() {
	// 1. Default compression round-trip
	{
		var buf bytes.Buffer
		w, err := flate.NewWriter(&buf, flate.DefaultCompression)
		if err != nil {
			panic(fmt.Sprintf("NewWriter(DefaultCompression) error: %v", err))
		}
		input := []byte("The quick brown fox jumps over the lazy dog. Repetition increases compressibility: The quick brown fox jumps over the lazy dog.")
		if _, err := w.Write(input); err != nil {
			panic(fmt.Sprintf("Write error: %v", err))
		}
		if err := w.Close(); err != nil {
			panic(fmt.Sprintf("Close error: %v", err))
		}

		r := flate.NewReader(&buf)
		got, err := io.ReadAll(r)
		_ = r.Close()
		if err != nil {
			panic(fmt.Sprintf("ReadAll error: %v", err))
		}
		if !bytes.Equal(got, input) {
			panic(fmt.Sprintf("DefaultCompression mismatch: got %q, want %q", got, input))
		}
	}

	// 2. Levels from BestSpeed (1) to BestCompression (9)
	{
		input := bytes.Repeat([]byte("klauspost-flate-multi-level-payload-data-verification-"), 40)
		for level := flate.BestSpeed; level <= flate.BestCompression; level++ {
			var buf bytes.Buffer
			w, err := flate.NewWriter(&buf, level)
			if err != nil {
				panic(fmt.Sprintf("NewWriter(level %d) error: %v", level, err))
			}
			if _, err := w.Write(input); err != nil {
				panic(fmt.Sprintf("Write(level %d) error: %v", level, err))
			}
			if err := w.Close(); err != nil {
				panic(fmt.Sprintf("Close(level %d) error: %v", level, err))
			}

			r := flate.NewReader(&buf)
			got, err := io.ReadAll(r)
			_ = r.Close()
			if err != nil {
				panic(fmt.Sprintf("ReadAll(level %d) error: %v", level, err))
			}
			if !bytes.Equal(got, input) {
				panic(fmt.Sprintf("level %d mismatch", level))
			}
		}
	}

	// 3. Special compression levels: NoCompression (0) and HuffmanOnly (-2)
	{
		specialLevels := []int{flate.NoCompression, flate.HuffmanOnly}
		input := []byte("Testing special compression modes: NoCompression and HuffmanOnly verification.")
		for _, level := range specialLevels {
			var buf bytes.Buffer
			w, err := flate.NewWriter(&buf, level)
			if err != nil {
				panic(fmt.Sprintf("NewWriter(level %d) error: %v", level, err))
			}
			if _, err := w.Write(input); err != nil {
				panic(fmt.Sprintf("Write(level %d) error: %v", level, err))
			}
			if err := w.Close(); err != nil {
				panic(fmt.Sprintf("Close(level %d) error: %v", level, err))
			}

			r := flate.NewReader(&buf)
			got, err := io.ReadAll(r)
			_ = r.Close()
			if err != nil {
				panic(fmt.Sprintf("ReadAll(level %d) error: %v", level, err))
			}
			if !bytes.Equal(got, input) {
				panic(fmt.Sprintf("level %d mismatch", level))
			}
		}
	}

	// 4. Invalid compression levels rejected
	{
		var buf bytes.Buffer
		for _, invalidLevel := range []int{-3, -10, 10, 15} {
			w, err := flate.NewWriter(&buf, invalidLevel)
			if err == nil {
				_ = w.Close()
				panic(fmt.Sprintf("expected error for invalid level %d, got nil", invalidLevel))
			}
			if !strings.Contains(err.Error(), "invalid compression level") {
				panic(fmt.Sprintf("unexpected error message for level %d: %v", invalidLevel, err))
			}
		}
	}

	// 5. Reset reuses writer
	{
		var buf1 bytes.Buffer
		w, err := flate.NewWriter(&buf1, flate.DefaultCompression)
		if err != nil {
			panic(fmt.Sprintf("NewWriter error: %v", err))
		}
		msg1 := []byte("first stream payload for flate writer reuse")
		if _, err := w.Write(msg1); err != nil {
			panic(fmt.Sprintf("Write msg1 error: %v", err))
		}
		if err := w.Close(); err != nil {
			panic(fmt.Sprintf("Close msg1 error: %v", err))
		}

		var buf2 bytes.Buffer
		w.Reset(&buf2)
		msg2 := []byte("second stream payload after reset reuse")
		if _, err := w.Write(msg2); err != nil {
			panic(fmt.Sprintf("Write msg2 error: %v", err))
		}
		if err := w.Close(); err != nil {
			panic(fmt.Sprintf("Close msg2 error: %v", err))
		}

		r1 := flate.NewReader(&buf1)
		got1, err := io.ReadAll(r1)
		_ = r1.Close()
		if err != nil || !bytes.Equal(got1, msg1) {
			panic(fmt.Sprintf("buf1 mismatch: %v, got %q", err, got1))
		}

		r2 := flate.NewReader(&buf2)
		got2, err := io.ReadAll(r2)
		_ = r2.Close()
		if err != nil || !bytes.Equal(got2, msg2) {
			panic(fmt.Sprintf("buf2 mismatch: %v, got %q", err, got2))
		}
	}

	fmt.Println("CONTRACT_VERIFIED: github.com/klauspost/compress/flate.NewWriter behaves as expected")
}