github.com/klauspost/compress v1.19.1: zstd.EncoderLevel

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

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:5844746ed3edc147efcec163ba8d511d0ed1a484e43be2b4d40c2b2ce9ae102f","contract":["EncoderLevel constants provide valid compression speed levels and string representations","EncoderLevelFromString parses level names and defaults on invalid input","EncoderLevelFromZstd maps standard zstd integer levels to appropriate EncoderLevel","WithEncoderLevel configures zstd encoder to successfully compress data recoverable by decoder"],"goal":"verify github.com/klauspost/compress/zstd.EncoderLevel 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/zstd.EncoderLevel"]},"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/zstd.EncoderLevel"],"verifierAdapter":"golang@1"}

module sample

go 1.26

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 sample

import (
	"bytes"
	"fmt"
	"io"

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

// PredefinedLevels returns all standard EncoderLevel constants.
func PredefinedLevels() []zstd.EncoderLevel {
	return []zstd.EncoderLevel{
		zstd.SpeedFastest,
		zstd.SpeedDefault,
		zstd.SpeedBetterCompression,
		zstd.SpeedBestCompression,
	}
}

// ParseEncoderLevel parses a string into an EncoderLevel.
func ParseEncoderLevel(s string) (bool, zstd.EncoderLevel) {
	return zstd.EncoderLevelFromString(s)
}

// MapZstdLevel maps a numerical zstd level to EncoderLevel.
func MapZstdLevel(level int) zstd.EncoderLevel {
	return zstd.EncoderLevelFromZstd(level)
}

// CompressWithLevel compresses data using the specified EncoderLevel option.
func CompressWithLevel(data []byte, level zstd.EncoderLevel) ([]byte, error) {
	var buf bytes.Buffer
	enc, err := zstd.NewWriter(&buf, zstd.WithEncoderLevel(level))
	if err != nil {
		return nil, fmt.Errorf("failed to create zstd writer: %w", err)
	}
	if _, err := enc.Write(data); err != nil {
		enc.Close()
		return nil, fmt.Errorf("failed to write data: %w", err)
	}
	if err := enc.Close(); err != nil {
		return nil, fmt.Errorf("failed to close zstd writer: %w", err)
	}
	return buf.Bytes(), nil
}

// Decompress decompresses zstd-compressed data.
func Decompress(compressed []byte) ([]byte, error) {
	dec, err := zstd.NewReader(bytes.NewReader(compressed))
	if err != nil {
		return nil, fmt.Errorf("failed to create zstd reader: %w", err)
	}
	defer dec.Close()
	return io.ReadAll(dec)
}

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

package main

import (
	"bytes"
	"fmt"
	"os"

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

func main() {
	// Assertion 1: EncoderLevel constants provide valid compression speed levels and string representations
	levels := sample.PredefinedLevels()
	expectedStrings := map[zstd.EncoderLevel]string{
		zstd.SpeedFastest:           "fastest",
		zstd.SpeedDefault:           "default",
		zstd.SpeedBetterCompression: "better",
		zstd.SpeedBestCompression:   "best",
	}

	for _, l := range levels {
		expected, exists := expectedStrings[l]
		if !exists {
			fmt.Fprintf(os.Stderr, "FAIL: unexpected EncoderLevel constant: %v\n", l)
			os.Exit(1)
		}
		if l.String() != expected {
			fmt.Fprintf(os.Stderr, "FAIL: expected %q, got %q\n", expected, l.String())
			os.Exit(1)
		}
	}

	// Assertion 2: EncoderLevelFromString parses level names and defaults on invalid input
	for level, name := range expectedStrings {
		ok, parsed := sample.ParseEncoderLevel(name)
		if !ok || parsed != level {
			fmt.Fprintf(os.Stderr, "FAIL: ParseEncoderLevel(%q) expected (%v, true), got (%v, %v)\n", name, level, parsed, ok)
			os.Exit(1)
		}
	}
	ok, parsedInvalid := sample.ParseEncoderLevel("invalid_compression_level")
	if ok || parsedInvalid != zstd.SpeedDefault {
		fmt.Fprintf(os.Stderr, "FAIL: expected invalid level to return false and SpeedDefault, got %v, %v\n", ok, parsedInvalid)
		os.Exit(1)
	}

	// Assertion 3: EncoderLevelFromZstd maps standard zstd integer levels to appropriate EncoderLevel
	mappingTests := []struct {
		zstdLevel int
		expected  zstd.EncoderLevel
	}{
		{1, zstd.SpeedFastest},
		{3, zstd.SpeedDefault},
		{7, zstd.SpeedBetterCompression},
		{19, zstd.SpeedBestCompression},
	}
	for _, tc := range mappingTests {
		actual := sample.MapZstdLevel(tc.zstdLevel)
		if actual != tc.expected {
			fmt.Fprintf(os.Stderr, "FAIL: MapZstdLevel(%d) expected %v, got %v\n", tc.zstdLevel, tc.expected, actual)
			os.Exit(1)
		}
	}

	// Assertion 4: WithEncoderLevel configures zstd encoder to successfully compress data recoverable by decoder
	payload := []byte("Hello, CodeSampleX! Verifying klauspost compress zstd EncoderLevel options.")
	for _, l := range levels {
		compressed, err := sample.CompressWithLevel(payload, l)
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: CompressWithLevel with %v failed: %v\n", l, err)
			os.Exit(1)
		}
		if len(compressed) == 0 {
			fmt.Fprintf(os.Stderr, "FAIL: compressed bytes empty for level %v\n", l)
			os.Exit(1)
		}

		decompressed, err := sample.Decompress(compressed)
		if err != nil {
			fmt.Fprintf(os.Stderr, "FAIL: Decompress failed for level %v: %v\n", l, err)
			os.Exit(1)
		}
		if !bytes.Equal(payload, decompressed) {
			fmt.Fprintf(os.Stderr, "FAIL: payload mismatch for level %v\n", l)
			os.Exit(1)
		}
	}

	fmt.Println("PASS: github.com/klauspost/compress/zstd.EncoderLevel contract verified")
}