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 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:
  - 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:401afcd741bd81baf69890787b802c354932ec733796ebd834db73e53ab6bcf5","contract":["flate.NewWriter creates a compressor writer with the specified compression level","flate.Writer writes and compresses data recoverable by flate.NewReader","flate.Writer.Flush flushes buffered compressed data to the underlying writer","flate.Writer.Reset reinitializes the compressor state for a new destination writer","flate.Writer.Close flushes remaining data and finalizes the compressed stream"],"goal":"verify 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":["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":["flate.NewWriter"],"verifierAdapter":"golang@1"}

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

package main

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

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

func main() {
	var buf bytes.Buffer
	w, err := flate.NewWriter(&buf, flate.DefaultCompression)
	if err != nil {
		fmt.Fprintf(os.Stderr, "failed to create flate writer: %v\n", err)
		os.Exit(1)
	}

	data := []byte("Hello, klauspost/compress flate writer demonstration!")
	if _, err := w.Write(data); err != nil {
		fmt.Fprintf(os.Stderr, "failed to write: %v\n", err)
		os.Exit(1)
	}

	if err := w.Close(); err != nil {
		fmt.Fprintf(os.Stderr, "failed to close writer: %v\n", err)
		os.Exit(1)
	}

	r := flate.NewReader(&buf)
	defer r.Close()

	decompressed, err := io.ReadAll(r)
	if err != nil {
		fmt.Fprintf(os.Stderr, "failed to read decompressed data: %v\n", err)
		os.Exit(1)
	}

	fmt.Printf("Original length: %d, compressed length: %d\n", len(data), buf.Len())
	fmt.Printf("Decompressed string: %s\n", string(decompressed))
}

{
  "schemaVersion": 1,
  "goal": "verify 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": [
    "flate.NewWriter"
  ]
}

package main

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

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

func main() {
	// 1. flate.NewWriter creates a compressor writer with the specified compression level
	var buf1 bytes.Buffer
	w1, err := flate.NewWriter(&buf1, flate.DefaultCompression)
	if err != nil {
		fmt.Fprintf(os.Stderr, "assertion 1 failed: NewWriter returned error: %v\n", err)
		os.Exit(1)
	}
	if w1 == nil {
		fmt.Fprintf(os.Stderr, "assertion 1 failed: NewWriter returned nil\n")
		os.Exit(1)
	}

	// Invalid level should return error
	_, errInvalid := flate.NewWriter(&buf1, -10)
	if errInvalid == nil {
		fmt.Fprintf(os.Stderr, "assertion 1 failed: expected error for invalid compression level\n")
		os.Exit(1)
	}

	// 2. flate.Writer writes and compresses data recoverable by flate.NewReader
	payload := []byte("The quick brown fox jumps over the lazy dog. Repeat: the quick brown fox jumps over the lazy dog.")
	n, err := w1.Write(payload)
	if err != nil {
		fmt.Fprintf(os.Stderr, "assertion 2 failed: Write returned error: %v\n", err)
		os.Exit(1)
	}
	if n != len(payload) {
		fmt.Fprintf(os.Stderr, "assertion 2 failed: Write wrote %d bytes, expected %d\n", n, len(payload))
		os.Exit(1)
	}

	// 3. flate.Writer.Flush flushes buffered compressed data to the underlying writer
	flushedLenBefore := buf1.Len()
	if err := w1.Flush(); err != nil {
		fmt.Fprintf(os.Stderr, "assertion 3 failed: Flush returned error: %v\n", err)
		os.Exit(1)
	}
	if buf1.Len() <= flushedLenBefore {
		fmt.Fprintf(os.Stderr, "assertion 3 failed: Flush did not output compressed data to buffer\n")
		os.Exit(1)
	}

	// 4. flate.Writer.Reset reinitializes the compressor state for a new destination writer
	var buf2 bytes.Buffer
	w1.Reset(&buf2)

	resetPayload := []byte("Testing Reset reinitializes compressor state with a fresh buffer target.")
	if _, err := w1.Write(resetPayload); err != nil {
		fmt.Fprintf(os.Stderr, "assertion 4 failed: Write after Reset error: %v\n", err)
		os.Exit(1)
	}
	if err := w1.Close(); err != nil {
		fmt.Fprintf(os.Stderr, "assertion 4 failed: Close after Reset error: %v\n", err)
		os.Exit(1)
	}

	rReset := flate.NewReader(&buf2)
	decompReset, err := io.ReadAll(rReset)
	rReset.Close()
	if err != nil {
		fmt.Fprintf(os.Stderr, "assertion 4 failed: ReadAll from reset reader error: %v\n", err)
		os.Exit(1)
	}
	if !bytes.Equal(decompReset, resetPayload) {
		fmt.Fprintf(os.Stderr, "assertion 4 failed: payload mismatch after reset\n")
		os.Exit(1)
	}

	// 5. flate.Writer.Close flushes remaining data and finalizes the compressed stream
	var buf3 bytes.Buffer
	w3, err := flate.NewWriter(&buf3, flate.BestSpeed)
	if err != nil {
		fmt.Fprintf(os.Stderr, "assertion 5 failed: NewWriter error: %v\n", err)
		os.Exit(1)
	}
	closePayload := []byte("Finalize test: verify Close finishes block properly")
	if _, err := w3.Write(closePayload); err != nil {
		fmt.Fprintf(os.Stderr, "assertion 5 failed: Write error: %v\n", err)
		os.Exit(1)
	}
	if err := w3.Close(); err != nil {
		fmt.Fprintf(os.Stderr, "assertion 5 failed: Close error: %v\n", err)
		os.Exit(1)
	}

	r3 := flate.NewReader(&buf3)
	decomp3, err := io.ReadAll(r3)
	r3.Close()
	if err != nil {
		fmt.Fprintf(os.Stderr, "assertion 5 failed: ReadAll decompressed error: %v\n", err)
		os.Exit(1)
	}
	if !bytes.Equal(decomp3, closePayload) {
		fmt.Fprintf(os.Stderr, "assertion 5 failed: decompressed payload mismatch: got %q, expected %q\n", decomp3, closePayload)
		os.Exit(1)
	}

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