github.com/klauspost/compress v1.20.0: zstd

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 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/zstd

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:88367fe47639d13e2f659794cc982709cc9f23127b1a8cad03bc7d58ffa94986","contract":["Encoder.EncodeAll and Decoder.DecodeAll roundtrip byte slice in block format","zstd.NewWriter and zstd.NewReader stream compress and decompress data to restore original payload","zstd.NewWriter with SpeedFastest and SpeedBestCompression levels compresses and roundtrips","zstd.NewWriter and zstd.NewReader correctly handle empty input payloads","Decoder.DecodeAll and zstd.NewReader return error when given corrupted or truncated data","Encoder and Decoder support stream reuse via Reset"],"goal":"verify github.com/klauspost/compress/zstd 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/zstd"]},"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/zstd"],"verifierAdapter":"golang@1"}

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

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

func main() {
	original := []byte("Hello, CodeSampleX with klauspost/compress zstd!")

	// Block format example
	enc, err := zstd.NewWriter(nil)
	if err != nil {
		log.Fatalf("failed to create zstd encoder: %v", err)
	}
	defer enc.Close()

	dec, err := zstd.NewReader(nil)
	if err != nil {
		log.Fatalf("failed to create zstd decoder: %v", err)
	}
	defer dec.Close()

	encoded := enc.EncodeAll(original, nil)
	decoded, err := dec.DecodeAll(encoded, nil)
	if err != nil {
		log.Fatalf("failed to decode zstd block: %v", err)
	}

	// Stream format example
	var buf bytes.Buffer
	writer, err := zstd.NewWriter(&buf)
	if err != nil {
		log.Fatalf("failed to create zstd writer: %v", err)
	}
	if _, err := writer.Write(original); err != nil {
		log.Fatalf("failed to write compressed stream: %v", err)
	}
	if err := writer.Close(); err != nil {
		log.Fatalf("failed to close zstd writer: %v", err)
	}

	reader, err := zstd.NewReader(&buf)
	if err != nil {
		log.Fatalf("failed to create zstd reader: %v", err)
	}
	defer reader.Close()

	decompressed, err := io.ReadAll(reader)
	if err != nil {
		log.Fatalf("failed to read decompressed stream: %v", err)
	}

	fmt.Printf("Original:        %s\n", string(original))
	fmt.Printf("Block Decoded:   %s\n", string(decoded))
	fmt.Printf("Stream Decoded:  %s\n", string(decompressed))
}

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

package main

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

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

func main() {
	// 1. Encoder.EncodeAll and Decoder.DecodeAll roundtrip byte slice in block format
	{
		original := []byte("CodeSampleX zstd block format verification payload.")
		enc, err := zstd.NewWriter(nil)
		if err != nil {
			fmt.Fprintf(os.Stderr, "zstd.NewWriter(nil) failed: %v\n", err)
			os.Exit(1)
		}
		defer enc.Close()

		dec, err := zstd.NewReader(nil)
		if err != nil {
			fmt.Fprintf(os.Stderr, "zstd.NewReader(nil) failed: %v\n", err)
			os.Exit(1)
		}
		defer dec.Close()

		encoded := enc.EncodeAll(original, nil)
		if len(encoded) == 0 {
			fmt.Fprintf(os.Stderr, "enc.EncodeAll produced empty output\n")
			os.Exit(1)
		}

		decoded, err := dec.DecodeAll(encoded, nil)
		if err != nil {
			fmt.Fprintf(os.Stderr, "dec.DecodeAll failed: %v\n", err)
			os.Exit(1)
		}
		if !bytes.Equal(original, decoded) {
			fmt.Fprintf(os.Stderr, "dec.DecodeAll mismatch: got %q, want %q\n", string(decoded), string(original))
			os.Exit(1)
		}
	}

	// 2. zstd.NewWriter and zstd.NewReader stream compress and decompress data to restore original payload
	{
		original := []byte("CodeSampleX zstd streaming format verification payload with high repetition. " +
			"Repeating stream data ensures blocks and framing are verified. ")
		original = bytes.Repeat(original, 10)

		var buf bytes.Buffer
		zw, err := zstd.NewWriter(&buf)
		if err != nil {
			fmt.Fprintf(os.Stderr, "zstd.NewWriter failed: %v\n", err)
			os.Exit(1)
		}
		if _, err := zw.Write(original); err != nil {
			fmt.Fprintf(os.Stderr, "zstd.NewWriter Write failed: %v\n", err)
			os.Exit(1)
		}
		if err := zw.Close(); err != nil {
			fmt.Fprintf(os.Stderr, "zstd.NewWriter Close failed: %v\n", err)
			os.Exit(1)
		}

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

		decompressed, err := io.ReadAll(zr)
		if err != nil {
			fmt.Fprintf(os.Stderr, "zstd.NewReader ReadAll failed: %v\n", err)
			os.Exit(1)
		}
		if !bytes.Equal(original, decompressed) {
			fmt.Fprintf(os.Stderr, "streaming roundtrip mismatch\n")
			os.Exit(1)
		}
	}

	// 3. zstd.NewWriter with SpeedFastest and SpeedBestCompression levels compresses and roundtrips
	{
		sampleData := bytes.Repeat([]byte("High repetition pattern for testing zstd writer compression levels. "), 40)
		for name, level := range map[string]zstd.EncoderLevel{
			"Fastest": zstd.SpeedFastest,
			"Best":    zstd.SpeedBestCompression,
		} {
			var b bytes.Buffer
			zw, err := zstd.NewWriter(&b, zstd.WithEncoderLevel(level))
			if err != nil {
				fmt.Fprintf(os.Stderr, "zstd.NewWriter with level %s failed: %v\n", name, err)
				os.Exit(1)
			}
			if _, err := zw.Write(sampleData); err != nil {
				fmt.Fprintf(os.Stderr, "zstd writer option %s Write failed: %v\n", name, err)
				os.Exit(1)
			}
			if err := zw.Close(); err != nil {
				fmt.Fprintf(os.Stderr, "zstd writer option %s Close failed: %v\n", name, err)
				os.Exit(1)
			}

			zr, err := zstd.NewReader(&b)
			if err != nil {
				fmt.Fprintf(os.Stderr, "zstd.NewReader for %s failed: %v\n", name, err)
				os.Exit(1)
			}
			decomp, err := io.ReadAll(zr)
			zr.Close()
			if err != nil {
				fmt.Fprintf(os.Stderr, "zstd reader ReadAll for %s failed: %v\n", name, err)
				os.Exit(1)
			}
			if !bytes.Equal(sampleData, decomp) {
				fmt.Fprintf(os.Stderr, "zstd option %s roundtrip mismatch\n", name)
				os.Exit(1)
			}
		}
	}

	// 4. zstd.NewWriter and zstd.NewReader correctly handle empty input payloads
	{
		var emptyBuf bytes.Buffer
		zwEmpty, err := zstd.NewWriter(&emptyBuf)
		if err != nil {
			fmt.Fprintf(os.Stderr, "zstd.NewWriter empty failed: %v\n", err)
			os.Exit(1)
		}
		if err := zwEmpty.Close(); err != nil {
			fmt.Fprintf(os.Stderr, "zstd empty writer close failed: %v\n", err)
			os.Exit(1)
		}

		zrEmpty, err := zstd.NewReader(&emptyBuf)
		if err != nil {
			fmt.Fprintf(os.Stderr, "zstd.NewReader empty failed: %v\n", err)
			os.Exit(1)
		}
		defer zrEmpty.Close()

		emptyDecomp, err := io.ReadAll(zrEmpty)
		if err != nil {
			fmt.Fprintf(os.Stderr, "zstd empty reader ReadAll failed: %v\n", err)
			os.Exit(1)
		}
		if len(emptyDecomp) != 0 {
			fmt.Fprintf(os.Stderr, "expected empty decompressed payload, got %d bytes\n", len(emptyDecomp))
			os.Exit(1)
		}
	}

	// 5. Decoder.DecodeAll and zstd.NewReader return error when given corrupted or truncated data
	{
		corruptedBlock := []byte{0xff, 0xff, 0xff, 0xff}
		decErr, err := zstd.NewReader(nil)
		if err != nil {
			fmt.Fprintf(os.Stderr, "zstd.NewReader(nil) failed: %v\n", err)
			os.Exit(1)
		}
		defer decErr.Close()

		_, decodeErr := decErr.DecodeAll(corruptedBlock, nil)
		if decodeErr == nil {
			fmt.Fprintf(os.Stderr, "expected error decoding corrupted block, got nil\n")
			os.Exit(1)
		}

		corruptedStream := []byte{0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc}
		zrBad, err := zstd.NewReader(bytes.NewReader(corruptedStream))
		if err == nil {
			_, streamErr := io.ReadAll(zrBad)
			zrBad.Close()
			if streamErr == nil {
				fmt.Fprintf(os.Stderr, "expected error reading corrupted stream, got nil\n")
				os.Exit(1)
			}
		}
	}

	// 6. Encoder and Decoder support stream reuse via Reset
	{
		var buf1 bytes.Buffer
		zwReuse, err := zstd.NewWriter(&buf1)
		if err != nil {
			fmt.Fprintf(os.Stderr, "zstd.NewWriter reuse failed: %v\n", err)
			os.Exit(1)
		}
		p1 := []byte("first stream payload for reusable zstd writer")
		if _, err := zwReuse.Write(p1); err != nil {
			fmt.Fprintf(os.Stderr, "p1 write failed: %v\n", err)
			os.Exit(1)
		}
		if err := zwReuse.Close(); err != nil {
			fmt.Fprintf(os.Stderr, "p1 close failed: %v\n", err)
			os.Exit(1)
		}

		var buf2 bytes.Buffer
		zwReuse.Reset(&buf2)
		p2 := []byte("second stream payload after zstd writer reset")
		if _, err := zwReuse.Write(p2); err != nil {
			fmt.Fprintf(os.Stderr, "p2 write failed: %v\n", err)
			os.Exit(1)
		}
		if err := zwReuse.Close(); err != nil {
			fmt.Fprintf(os.Stderr, "p2 close failed: %v\n", err)
			os.Exit(1)
		}

		zrReuse, err := zstd.NewReader(&buf1)
		if err != nil {
			fmt.Fprintf(os.Stderr, "zstd.NewReader reuse buf1 failed: %v\n", err)
			os.Exit(1)
		}
		res1, err := io.ReadAll(zrReuse)
		if err != nil || !bytes.Equal(res1, p1) {
			fmt.Fprintf(os.Stderr, "p1 mismatch: %v\n", err)
			os.Exit(1)
		}

		if err := zrReuse.Reset(&buf2); err != nil {
			fmt.Fprintf(os.Stderr, "zrReuse.Reset failed: %v\n", err)
			os.Exit(1)
		}
		res2, err := io.ReadAll(zrReuse)
		zrReuse.Close()
		if err != nil || !bytes.Equal(res2, p2) {
			fmt.Fprintf(os.Stderr, "p2 mismatch: %v\n", err)
			os.Exit(1)
		}
	}

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