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

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

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:1efd294b3d340e67442310df1e802d680da0ddbc0444d9a1dd8571f4abb673be","contract":["zlib.NewWriterLevel initializes a writer with specified compression levels and compresses data correctly","zlib.NewWriterLevel supports standard compression levels NoCompression, BestSpeed, DefaultCompression, and BestCompression","zlib.NewWriterLevel supports HuffmanOnly compression mode","zlib.NewWriterLevel rejects invalid compression levels below HuffmanOnly or above BestCompression with an error","zlib.NewWriterLevel emits valid zlib stream header and trailer for empty payloads","zlib.NewWriterLevel Flush flushes pending compressed bytes to destination"],"goal":"verify github.com/klauspost/compress/zlib.NewWriterLevel 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.NewWriterLevel"]},"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.NewWriterLevel"],"verifierAdapter":"golang@1"}

module example.com/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 main() {
	input := []byte("Demonstrating zlib.NewWriterLevel compression with github.com/klauspost/compress.")

	var compressedBuf bytes.Buffer
	writer, err := zlib.NewWriterLevel(&compressedBuf, zlib.BestCompression)
	if err != nil {
		log.Fatalf("failed to create zlib writer with level: %v", err)
	}

	if _, err := writer.Write(input); 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(&compressedBuf)
	if err != nil {
		log.Fatalf("failed to open 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(input))
	fmt.Printf("Decompressed: %s\n", string(decompressed))
}

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

package main

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

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

func main() {
	// 1. zlib.NewWriterLevel initializes a writer with specified compression levels and compresses data correctly
	{
		original := []byte("CodeSampleX contract verification: klauspost/compress/zlib.NewWriterLevel standard stream roundtrip test.")
		var buf bytes.Buffer
		zw, err := zlib.NewWriterLevel(&buf, zlib.DefaultCompression)
		if err != nil {
			fmt.Fprintf(os.Stderr, "zlib.NewWriterLevel DefaultCompression error: %v\n", err)
			os.Exit(1)
		}
		if _, err := zw.Write(original); err != nil {
			fmt.Fprintf(os.Stderr, "zlib.NewWriterLevel Write error: %v\n", err)
			os.Exit(1)
		}
		if err := zw.Close(); err != nil {
			fmt.Fprintf(os.Stderr, "zlib.NewWriterLevel Close error: %v\n", err)
			os.Exit(1)
		}

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

	// 2. zlib.NewWriterLevel supports standard compression levels NoCompression, BestSpeed, DefaultCompression, and BestCompression
	{
		sampleData := bytes.Repeat([]byte("Evaluating compression ratio and integrity across distinct zlib compression levels. "), 30)
		levels := []int{
			zlib.NoCompression,
			zlib.BestSpeed,
			zlib.DefaultCompression,
			zlib.BestCompression,
		}

		for _, lvl := range levels {
			var buf bytes.Buffer
			zw, err := zlib.NewWriterLevel(&buf, lvl)
			if err != nil {
				fmt.Fprintf(os.Stderr, "zlib.NewWriterLevel(%d) error: %v\n", lvl, err)
				os.Exit(1)
			}
			if _, err := zw.Write(sampleData); err != nil {
				fmt.Fprintf(os.Stderr, "zw.Write with level %d error: %v\n", lvl, err)
				os.Exit(1)
			}
			if err := zw.Close(); err != nil {
				fmt.Fprintf(os.Stderr, "zw.Close with level %d error: %v\n", lvl, err)
				os.Exit(1)
			}

			zr, err := zlib.NewReader(&buf)
			if err != nil {
				fmt.Fprintf(os.Stderr, "zlib.NewReader with level %d error: %v\n", lvl, err)
				os.Exit(1)
			}
			decomp, err := io.ReadAll(zr)
			if err != nil {
				fmt.Fprintf(os.Stderr, "zlib.NewReader ReadAll with level %d error: %v\n", lvl, err)
				os.Exit(1)
			}
			if err := zr.Close(); err != nil {
				fmt.Fprintf(os.Stderr, "zlib.NewReader Close with level %d error: %v\n", lvl, err)
				os.Exit(1)
			}
			if !bytes.Equal(sampleData, decomp) {
				fmt.Fprintf(os.Stderr, "level %d roundtrip mismatch\n", lvl)
				os.Exit(1)
			}
		}
	}

	// 3. zlib.NewWriterLevel supports HuffmanOnly compression mode
	{
		payload := bytes.Repeat([]byte("HuffmanOnly entropy coding test with repeating patterns and ASCII symbols. "), 25)
		var buf bytes.Buffer
		zw, err := zlib.NewWriterLevel(&buf, zlib.HuffmanOnly)
		if err != nil {
			fmt.Fprintf(os.Stderr, "zlib.NewWriterLevel HuffmanOnly error: %v\n", err)
			os.Exit(1)
		}
		if _, err := zw.Write(payload); err != nil {
			fmt.Fprintf(os.Stderr, "HuffmanOnly Write error: %v\n", err)
			os.Exit(1)
		}
		if err := zw.Close(); err != nil {
			fmt.Fprintf(os.Stderr, "HuffmanOnly Close error: %v\n", err)
			os.Exit(1)
		}

		zr, err := zlib.NewReader(&buf)
		if err != nil {
			fmt.Fprintf(os.Stderr, "zlib.NewReader HuffmanOnly error: %v\n", err)
			os.Exit(1)
		}
		decomp, err := io.ReadAll(zr)
		if err != nil {
			fmt.Fprintf(os.Stderr, "zlib.NewReader ReadAll HuffmanOnly error: %v\n", err)
			os.Exit(1)
		}
		if err := zr.Close(); err != nil {
			fmt.Fprintf(os.Stderr, "zlib.NewReader Close HuffmanOnly error: %v\n", err)
			os.Exit(1)
		}
		if !bytes.Equal(payload, decomp) {
			fmt.Fprintf(os.Stderr, "HuffmanOnly decomp mismatch\n")
			os.Exit(1)
		}
	}

	// 4. zlib.NewWriterLevel rejects invalid compression levels below HuffmanOnly or above BestCompression with an error
	{
		var buf bytes.Buffer
		invalidLevels := []int{-3, -10, 10, 99}
		for _, lvl := range invalidLevels {
			zw, err := zlib.NewWriterLevel(&buf, lvl)
			if err == nil {
				fmt.Fprintf(os.Stderr, "expected error for invalid compression level %d, got nil\n", lvl)
				if zw != nil {
					_ = zw.Close()
				}
				os.Exit(1)
			}
		}
	}

	// 5. zlib.NewWriterLevel emits valid zlib stream header and trailer for empty payloads
	{
		var buf bytes.Buffer
		zw, err := zlib.NewWriterLevel(&buf, zlib.BestSpeed)
		if err != nil {
			fmt.Fprintf(os.Stderr, "empty stream zlib.NewWriterLevel error: %v\n", err)
			os.Exit(1)
		}
		if err := zw.Close(); err != nil {
			fmt.Fprintf(os.Stderr, "empty stream zw.Close error: %v\n", err)
			os.Exit(1)
		}
		if buf.Len() == 0 {
			fmt.Fprintf(os.Stderr, "expected header/footer bytes for empty stream, got 0\n")
			os.Exit(1)
		}

		zr, err := zlib.NewReader(&buf)
		if err != nil {
			fmt.Fprintf(os.Stderr, "empty stream zlib.NewReader error: %v\n", err)
			os.Exit(1)
		}
		out, err := io.ReadAll(zr)
		if err != nil {
			fmt.Fprintf(os.Stderr, "empty stream ReadAll error: %v\n", err)
			os.Exit(1)
		}
		if err := zr.Close(); err != nil {
			fmt.Fprintf(os.Stderr, "empty stream zr.Close error: %v\n", err)
			os.Exit(1)
		}
		if len(out) != 0 {
			fmt.Fprintf(os.Stderr, "expected 0 decompressed bytes, got %d\n", len(out))
			os.Exit(1)
		}
	}

	// 6. zlib.NewWriterLevel Flush flushes pending compressed bytes to destination
	{
		var buf bytes.Buffer
		zw, err := zlib.NewWriterLevel(&buf, zlib.DefaultCompression)
		if err != nil {
			fmt.Fprintf(os.Stderr, "Flush test zlib.NewWriterLevel error: %v\n", err)
			os.Exit(1)
		}
		msg := []byte("intermediate payload chunk for Flush testing")
		if _, err := zw.Write(msg); err != nil {
			fmt.Fprintf(os.Stderr, "Flush Write error: %v\n", err)
			os.Exit(1)
		}
		if err := zw.Flush(); err != nil {
			fmt.Fprintf(os.Stderr, "Flush() error: %v\n", err)
			os.Exit(1)
		}
		if buf.Len() == 0 {
			fmt.Fprintf(os.Stderr, "expected non-zero bytes after Flush, got 0\n")
			os.Exit(1)
		}
		if err := zw.Close(); err != nil {
			fmt.Fprintf(os.Stderr, "zw.Close after flush error: %v\n", err)
			os.Exit(1)
		}

		zr, err := zlib.NewReader(&buf)
		if err != nil {
			fmt.Fprintf(os.Stderr, "zlib.NewReader after Flush error: %v\n", err)
			os.Exit(1)
		}
		decomp, err := io.ReadAll(zr)
		if err != nil || !bytes.Equal(decomp, msg) {
			fmt.Fprintf(os.Stderr, "Flush roundtrip mismatch: %v\n", err)
			os.Exit(1)
		}
		_ = zr.Close()
	}

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