github.com/klauspost/compress v1.18.0: zstd.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/zstd.NewWriter in pkg:golang/github.com/klauspost/compress@v1.18.0
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/klauspost/compress@v1.18.0
Demonstrate these symbols/APIs:
  - github.com/klauspost/compress/zstd.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:bff970718bd2af430cc4466a2e34913a77afe50226b359129f1fd27b546f712e","contract":["zstd.NewWriter compresses payloads across various encoder speed levels and restores exact original bytes","zstd.NewWriter compresses streamed multiple chunk writes into a valid decompressable zstd stream","zstd.NewWriter instances can be reused via Reset to compress subsequent payloads independently","zstd.NewWriter correctly compresses and flushes empty input payloads"],"goal":"verify github.com/klauspost/compress/zstd.NewWriter in pkg:golang/github.com/klauspost/compress@v1.18.0","kind":"HOW","packages":["pkg:golang/github.com/klauspost/compress@v1.18.0"],"schemaVersion":1,"symbols":["github.com/klauspost/compress/zstd.NewWriter"]},"contractCommand":["go","test","-v","./..."],"environment":{"arch":"amd64","compiler":"go","compilerVersion":"1.26.6","distro":"ubuntu","ecosystem":"golang","language":"go","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.18.0"],"schemaVersion":1,"subject":"pkg:golang/github.com/klauspost/compress@v1.18.0","symbols":["github.com/klauspost/compress/zstd.NewWriter"],"verifierAdapter":"golang@1"}

module example.com/zstd-writer-sample

go 1.22

require github.com/klauspost/compress v1.18.0

github.com/klauspost/compress v1.18.0 h1:c/Cqfb0r+Yi+JtIEq73FWXVkRonBlf0CRNYc8Zttxdo=
github.com/klauspost/compress v1.18.0/go.mod h1:2Pp+KzxcywXVXMr50+X0Q/Lsb43OQHYWRCY2AiWywWQ=

{
  "schemaVersion": 1,
  "goal": "verify github.com/klauspost/compress/zstd.NewWriter in pkg:golang/github.com/klauspost/compress@v1.18.0",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/klauspost/compress@v1.18.0"
  ],
  "symbols": [
    "github.com/klauspost/compress/zstd.NewWriter"
  ]
}

package sample

import (
	"bytes"
	"fmt"
	"io"

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

// CompressWithLevel compresses the input data using zstd.NewWriter with a specified compression level.
func CompressWithLevel(src []byte, level zstd.EncoderLevel) ([]byte, error) {
	var buf bytes.Buffer
	writer, err := zstd.NewWriter(&buf, zstd.WithEncoderLevel(level))
	if err != nil {
		return nil, fmt.Errorf("failed to create zstd writer: %w", err)
	}

	if _, err := writer.Write(src); err != nil {
		_ = writer.Close()
		return nil, fmt.Errorf("failed to write compressed data: %w", err)
	}

	if err := writer.Close(); err != nil {
		return nil, fmt.Errorf("failed to close zstd writer: %w", err)
	}

	return buf.Bytes(), nil
}

// CompressStreaming writes multiple chunks to a zstd.NewWriter and flushes on close.
func CompressStreaming(chunks [][]byte) ([]byte, error) {
	var buf bytes.Buffer
	writer, err := zstd.NewWriter(&buf)
	if err != nil {
		return nil, fmt.Errorf("failed to create zstd writer: %w", err)
	}

	for _, chunk := range chunks {
		if _, err := writer.Write(chunk); err != nil {
			_ = writer.Close()
			return nil, fmt.Errorf("failed to write chunk: %w", err)
		}
	}

	if err := writer.Close(); err != nil {
		return nil, fmt.Errorf("failed to close zstd writer: %w", err)
	}

	return buf.Bytes(), nil
}

// CompressAndReset demonstrates reusing a zstd.NewWriter instance via Reset.
func CompressAndReset(first []byte, second []byte) ([]byte, []byte, error) {
	var buf1 bytes.Buffer
	writer, err := zstd.NewWriter(&buf1)
	if err != nil {
		return nil, nil, fmt.Errorf("failed to create zstd writer: %w", err)
	}

	if _, err := writer.Write(first); err != nil {
		_ = writer.Close()
		return nil, nil, fmt.Errorf("failed to write first payload: %w", err)
	}
	if err := writer.Close(); err != nil {
		return nil, nil, fmt.Errorf("failed to close writer for first payload: %w", err)
	}

	var buf2 bytes.Buffer
	writer.Reset(&buf2)

	if _, err := writer.Write(second); err != nil {
		_ = writer.Close()
		return nil, nil, fmt.Errorf("failed to write second payload: %w", err)
	}
	if err := writer.Close(); err != nil {
		return nil, nil, fmt.Errorf("failed to close writer for second payload: %w", err)
	}

	return buf1.Bytes(), buf2.Bytes(), nil
}

// Decompress reads zstd-compressed bytes to verify writer output.
func Decompress(src []byte) ([]byte, error) {
	reader, err := zstd.NewReader(bytes.NewReader(src))
	if err != nil {
		return nil, fmt.Errorf("failed to create zstd reader: %w", err)
	}
	defer reader.Close()

	decompressed, err := io.ReadAll(reader)
	if err != nil {
		return nil, fmt.Errorf("failed to read decompressed data: %w", err)
	}

	return decompressed, nil
}

package sample

import (
	"bytes"
	"testing"

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

func TestNewWriterCompressionLevels(t *testing.T) {
	payload := []byte("CodeSampleX verification payload for zstd.NewWriter with various compression levels.")

	levels := []zstd.EncoderLevel{
		zstd.SpeedFastest,
		zstd.SpeedDefault,
		zstd.SpeedBetterCompression,
		zstd.SpeedBestCompression,
	}

	for _, level := range levels {
		compressed, err := CompressWithLevel(payload, level)
		if err != nil {
			t.Fatalf("CompressWithLevel failed for level %v: %v", level, err)
		}

		decompressed, err := Decompress(compressed)
		if err != nil {
			t.Fatalf("Decompress failed for level %v: %v", level, err)
		}

		if !bytes.Equal(payload, decompressed) {
			t.Fatalf("Decompressed mismatch for level %v: got %q, want %q", level, decompressed, payload)
		}
	}
}

func TestNewWriterStreaming(t *testing.T) {
	chunks := [][]byte{
		[]byte("Chunk 1: Initializing zstd stream. "),
		[]byte("Chunk 2: Appending additional structured data. "),
		[]byte("Chunk 3: Finalizing multi-chunk compression test."),
	}
	expected := bytes.Join(chunks, nil)

	compressed, err := CompressStreaming(chunks)
	if err != nil {
		t.Fatalf("CompressStreaming failed: %v", err)
	}

	decompressed, err := Decompress(compressed)
	if err != nil {
		t.Fatalf("Decompress failed: %v", err)
	}

	if !bytes.Equal(expected, decompressed) {
		t.Fatalf("Streaming decompressed mismatch: got %q, want %q", decompressed, expected)
	}
}

func TestNewWriterReset(t *testing.T) {
	first := []byte("First dataset to be compressed with zstd writer.")
	second := []byte("Second dataset to be compressed using the reset zstd writer instance.")

	comp1, comp2, err := CompressAndReset(first, second)
	if err != nil {
		t.Fatalf("CompressAndReset failed: %v", err)
	}

	decomp1, err := Decompress(comp1)
	if err != nil {
		t.Fatalf("Decompress first failed: %v", err)
	}
	if !bytes.Equal(first, decomp1) {
		t.Fatalf("Decompressed first mismatch: got %q, want %q", decomp1, first)
	}

	decomp2, err := Decompress(comp2)
	if err != nil {
		t.Fatalf("Decompress second failed: %v", err)
	}
	if !bytes.Equal(second, decomp2) {
		t.Fatalf("Decompressed second mismatch: got %q, want %q", decomp2, second)
	}
}

func TestNewWriterEmptyPayload(t *testing.T) {
	empty := []byte("")
	compressed, err := CompressWithLevel(empty, zstd.SpeedDefault)
	if err != nil {
		t.Fatalf("Compress empty failed: %v", err)
	}

	decompressed, err := Decompress(compressed)
	if err != nil {
		t.Fatalf("Decompress empty failed: %v", err)
	}

	if !bytes.Equal(empty, decompressed) {
		t.Fatalf("Decompressed empty mismatch: got %q, want %q", decompressed, empty)
	}
}