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

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.Writer 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.Writer

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:efd95e154ea8db1c4bd76eabf30387dedbb9ff05adc3e9fb2a9f58cf134a4bd1","contract":["zlib.NewWriter creates a Writer that compresses data decodable by zlib.NewReader","zlib.Writer Flush forces buffered compressed data to be written to the underlying writer","zlib.Writer Reset clears writer state and redirects output to a new io.Writer","zlib.NewWriterLevel configures custom compression levels including BestSpeed and BestCompression","zlib.NewWriterLevelDict and zlib.NewReaderDict compress and decompress data using a preset dictionary"],"goal":"verify github.com/klauspost/compress/zlib.Writer 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.Writer"]},"contractCommand":["go","run","./test"],"environment":{"arch":"amd64","compiler":"go","compilerVersion":"1.26.6","distro":"ubuntu","ecosystem":"golang","language":"go","languageVersion":"1.26.6","libc":"glibc","libcVersion":"2.39","os":"linux","osVersionBucket":"24","packageManager":"go","packageManagerVersion":"1.26.6","runtime":"go","runtimeVersion":"1.26.6","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.Writer"],"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"

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

func main() {
	var buf bytes.Buffer

	// Create a new zlib writer compressing into buf
	writer := zlib.NewWriter(&buf)

	data := []byte("CodeSampleX verification of klauspost/compress zlib.Writer")
	if _, err := writer.Write(data); err != nil {
		panic(err)
	}

	if err := writer.Close(); err != nil {
		panic(err)
	}

	compressedLen := buf.Len()

	// Decompress and verify
	reader, err := zlib.NewReader(&buf)
	if err != nil {
		panic(err)
	}
	defer reader.Close()

	decompressed, err := io.ReadAll(reader)
	if err != nil {
		panic(err)
	}

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

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

package main

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

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

func main() {
	// Assertion 1: zlib.NewWriter creates a Writer that compresses data decodable by zlib.NewReader
	{
		var buf bytes.Buffer
		writer := zlib.NewWriter(&buf)
		original := []byte("Assertion 1: stream compression with default level")

		n, err := writer.Write(original)
		if err != nil {
			fmt.Fprintf(os.Stderr, "assertion 1 write failed: %v\n", err)
			os.Exit(1)
		}
		if n != len(original) {
			fmt.Fprintf(os.Stderr, "assertion 1 wrote %d bytes, expected %d\n", n, len(original))
			os.Exit(1)
		}

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

		reader, err := zlib.NewReader(&buf)
		if err != nil {
			fmt.Fprintf(os.Stderr, "assertion 1 reader create failed: %v\n", err)
			os.Exit(1)
		}
		defer reader.Close()

		decompressed, err := io.ReadAll(reader)
		if err != nil {
			fmt.Fprintf(os.Stderr, "assertion 1 read failed: %v\n", err)
			os.Exit(1)
		}
		if !bytes.Equal(decompressed, original) {
			fmt.Fprintf(os.Stderr, "assertion 1 data mismatch: expected %q, got %q\n", original, decompressed)
			os.Exit(1)
		}
	}

	// Assertion 2: zlib.Writer Flush forces buffered compressed data to be written to the underlying writer
	{
		var buf bytes.Buffer
		writer := zlib.NewWriter(&buf)
		part := []byte("flush test payload data")

		if _, err := writer.Write(part); err != nil {
			fmt.Fprintf(os.Stderr, "assertion 2 write failed: %v\n", err)
			os.Exit(1)
		}

		// Flush writes compressed blocks to buffer without closing the stream
		if err := writer.Flush(); err != nil {
			fmt.Fprintf(os.Stderr, "assertion 2 flush failed: %v\n", err)
			os.Exit(1)
		}

		if buf.Len() == 0 {
			fmt.Fprintf(os.Stderr, "assertion 2 failed: expected buffer to contain flushed bytes\n")
			os.Exit(1)
		}

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

	// Assertion 3: zlib.Writer Reset clears writer state and redirects output to a new io.Writer
	{
		var buf1, buf2 bytes.Buffer
		writer := zlib.NewWriter(&buf1)

		if _, err := writer.Write([]byte("stream 1")); err != nil {
			fmt.Fprintf(os.Stderr, "assertion 3 write 1 failed: %v\n", err)
			os.Exit(1)
		}
		if err := writer.Close(); err != nil {
			fmt.Fprintf(os.Stderr, "assertion 3 close 1 failed: %v\n", err)
			os.Exit(1)
		}

		// Reset to buf2
		writer.Reset(&buf2)
		expected2 := []byte("stream 2 reset test")
		if _, err := writer.Write(expected2); err != nil {
			fmt.Fprintf(os.Stderr, "assertion 3 write 2 failed: %v\n", err)
			os.Exit(1)
		}
		if err := writer.Close(); err != nil {
			fmt.Fprintf(os.Stderr, "assertion 3 close 2 failed: %v\n", err)
			os.Exit(1)
		}

		reader, err := zlib.NewReader(&buf2)
		if err != nil {
			fmt.Fprintf(os.Stderr, "assertion 3 reader create failed: %v\n", err)
			os.Exit(1)
		}
		defer reader.Close()

		res, err := io.ReadAll(reader)
		if err != nil || !bytes.Equal(res, expected2) {
			fmt.Fprintf(os.Stderr, "assertion 3 data mismatch: expected %q, got %q, err: %v\n", expected2, res, err)
			os.Exit(1)
		}
	}

	// Assertion 4: zlib.NewWriterLevel configures custom compression levels including BestSpeed and BestCompression
	{
		var bufSpeed, bufComp bytes.Buffer
		writerSpeed, err := zlib.NewWriterLevel(&bufSpeed, zlib.BestSpeed)
		if err != nil {
			fmt.Fprintf(os.Stderr, "assertion 4 BestSpeed creation failed: %v\n", err)
			os.Exit(1)
		}

		writerComp, err := zlib.NewWriterLevel(&bufComp, zlib.BestCompression)
		if err != nil {
			fmt.Fprintf(os.Stderr, "assertion 4 BestCompression creation failed: %v\n", err)
			os.Exit(1)
		}

		payload := bytes.Repeat([]byte("repetitive compression payload data 1234567890 "), 50)
		if _, err := writerSpeed.Write(payload); err != nil {
			fmt.Fprintf(os.Stderr, "assertion 4 speed write failed: %v\n", err)
			os.Exit(1)
		}
		if err := writerSpeed.Close(); err != nil {
			fmt.Fprintf(os.Stderr, "assertion 4 speed close failed: %v\n", err)
			os.Exit(1)
		}

		if _, err := writerComp.Write(payload); err != nil {
			fmt.Fprintf(os.Stderr, "assertion 4 comp write failed: %v\n", err)
			os.Exit(1)
		}
		if err := writerComp.Close(); err != nil {
			fmt.Fprintf(os.Stderr, "assertion 4 comp close failed: %v\n", err)
			os.Exit(1)
		}

		// BestCompression should produce smaller or equal size compared to BestSpeed
		if bufComp.Len() > bufSpeed.Len() {
			fmt.Fprintf(os.Stderr, "assertion 4 failed: BestCompression (%d) > BestSpeed (%d)\n", bufComp.Len(), bufSpeed.Len())
			os.Exit(1)
		}
	}

	// Assertion 5: zlib.NewWriterLevelDict and zlib.NewReaderDict compress and decompress data using a preset dictionary
	{
		var buf bytes.Buffer
		dict := []byte("preset custom dictionary keys and values")
		writer, err := zlib.NewWriterLevelDict(&buf, zlib.DefaultCompression, dict)
		if err != nil {
			fmt.Fprintf(os.Stderr, "assertion 5 NewWriterLevelDict failed: %v\n", err)
			os.Exit(1)
		}

		data := []byte("custom dictionary test data")
		if _, err := writer.Write(data); err != nil {
			fmt.Fprintf(os.Stderr, "assertion 5 dict write failed: %v\n", err)
			os.Exit(1)
		}
		if err := writer.Close(); err != nil {
			fmt.Fprintf(os.Stderr, "assertion 5 dict close failed: %v\n", err)
			os.Exit(1)
		}

		reader, err := zlib.NewReaderDict(&buf, dict)
		if err != nil {
			fmt.Fprintf(os.Stderr, "assertion 5 NewReaderDict failed: %v\n", err)
			os.Exit(1)
		}
		defer reader.Close()

		res, err := io.ReadAll(reader)
		if err != nil || !bytes.Equal(res, data) {
			fmt.Fprintf(os.Stderr, "assertion 5 data mismatch: expected %q, got %q, err: %v\n", data, res, err)
			os.Exit(1)
		}
	}

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