github.com/klauspost/compress v1.20.0: snappy.Decode, snappy.Encode, snappy.NewReader

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 snappy compression and decompression 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/snappy.Decode
  - github.com/klauspost/compress/snappy.Encode
  - github.com/klauspost/compress/snappy.NewReader
  - github.com/klauspost/compress/snappy.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:a5b9767e0810e6a1baaa6434dc6cac3c7900e771396c250e22ee60a8d74ef891","contract":["snappy.Encode compresses byte slice and snappy.Decode decompresses to restore exact original payload","snappy.Encode and snappy.Decode correctly roundtrip empty byte slice","snappy.Decode returns error when given invalid or corrupted snappy byte slice","snappy.NewWriter compresses data stream and snappy.NewReader decompresses to restore exact original payload","snappy.NewWriter and snappy.NewReader support stream reuse via Reset","snappy.NewReader returns error when reading corrupted or invalid snappy stream"],"goal":"verify snappy compression and decompression 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/snappy.Decode","github.com/klauspost/compress/snappy.Encode","github.com/klauspost/compress/snappy.NewReader","github.com/klauspost/compress/snappy.NewWriter"]},"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/snappy.Decode","github.com/klauspost/compress/snappy.Encode","github.com/klauspost/compress/snappy.NewReader","github.com/klauspost/compress/snappy.NewWriter"],"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/snappy"
)

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

	// Block compression: Encode and Decode
	encoded := snappy.Encode(nil, original)
	decoded, err := snappy.Decode(nil, encoded)
	if err != nil {
		log.Fatalf("snappy decode failed: %v", err)
	}

	fmt.Printf("Original:       %s\n", string(original))
	fmt.Printf("Decoded block:  %s\n", string(decoded))

	// Stream compression: NewWriter and NewReader
	var buf bytes.Buffer
	writer := snappy.NewWriter(&buf)
	if _, err := writer.Write(original); err != nil {
		log.Fatalf("snappy stream write failed: %v", err)
	}
	if err := writer.Close(); err != nil {
		log.Fatalf("snappy stream close failed: %v", err)
	}

	reader := snappy.NewReader(&buf)
	streamDecoded, err := io.ReadAll(reader)
	if err != nil {
		log.Fatalf("snappy stream read failed: %v", err)
	}

	fmt.Printf("Stream decoded: %s\n", string(streamDecoded))
}

{
  "schemaVersion": 1,
  "goal": "verify snappy compression and decompression 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/snappy.Decode",
    "github.com/klauspost/compress/snappy.Encode",
    "github.com/klauspost/compress/snappy.NewReader",
    "github.com/klauspost/compress/snappy.NewWriter"
  ]
}

package main

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

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

func main() {
	// 1. snappy.Encode compresses byte slice and snappy.Decode decompresses to restore exact original payload
	{
		original := []byte("CodeSampleX contract verification payload for klauspost/compress snappy block encoding.")
		encoded := snappy.Encode(nil, original)
		if len(encoded) == 0 {
			fmt.Fprintf(os.Stderr, "snappy.Encode returned empty slice\n")
			os.Exit(1)
		}
		decoded, err := snappy.Decode(nil, encoded)
		if err != nil {
			fmt.Fprintf(os.Stderr, "snappy.Decode failed: %v\n", err)
			os.Exit(1)
		}
		if !bytes.Equal(original, decoded) {
			fmt.Fprintf(os.Stderr, "block decoded mismatch: got %q, want %q\n", string(decoded), string(original))
			os.Exit(1)
		}
	}

	// 2. snappy.Encode and snappy.Decode correctly roundtrip empty byte slice
	{
		emptyOriginal := []byte{}
		encoded := snappy.Encode(nil, emptyOriginal)
		decoded, err := snappy.Decode(nil, encoded)
		if err != nil {
			fmt.Fprintf(os.Stderr, "snappy.Decode empty payload failed: %v\n", err)
			os.Exit(1)
		}
		if len(decoded) != 0 {
			fmt.Fprintf(os.Stderr, "expected empty decoded slice, got len %d\n", len(decoded))
			os.Exit(1)
		}
	}

	// 3. snappy.Decode returns error when given invalid or corrupted snappy byte slice
	{
		corrupted := []byte{0xff, 0xff, 0xff, 0xff}
		_, err := snappy.Decode(nil, corrupted)
		if err == nil {
			fmt.Fprintf(os.Stderr, "expected error decoding corrupted bytes, got nil\n")
			os.Exit(1)
		}
	}

	// 4. snappy.NewWriter compresses data stream and snappy.NewReader decompresses to restore exact original payload
	{
		payload := bytes.Repeat([]byte("Streaming payload for testing klauspost/compress snappy reader and writer. "), 20)
		var buf bytes.Buffer
		sw := snappy.NewWriter(&buf)
		if _, err := sw.Write(payload); err != nil {
			fmt.Fprintf(os.Stderr, "snappy stream write failed: %v\n", err)
			os.Exit(1)
		}
		if err := sw.Close(); err != nil {
			fmt.Fprintf(os.Stderr, "snappy stream close failed: %v\n", err)
			os.Exit(1)
		}

		sr := snappy.NewReader(&buf)
		decompressed, err := io.ReadAll(sr)
		if err != nil {
			fmt.Fprintf(os.Stderr, "snappy stream read failed: %v\n", err)
			os.Exit(1)
		}
		if !bytes.Equal(payload, decompressed) {
			fmt.Fprintf(os.Stderr, "stream decompressed mismatch\n")
			os.Exit(1)
		}
	}

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

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

		srReuse := snappy.NewReader(&b1)
		r1, err := io.ReadAll(srReuse)
		if err != nil || !bytes.Equal(r1, p1) {
			fmt.Fprintf(os.Stderr, "srReuse b1 read failed: %v\n", err)
			os.Exit(1)
		}

		srReuse.Reset(&b2)
		r2, err := io.ReadAll(srReuse)
		if err != nil || !bytes.Equal(r2, p2) {
			fmt.Fprintf(os.Stderr, "srReuse b2 read failed: %v\n", err)
			os.Exit(1)
		}
	}

	// 6. snappy.NewReader returns error when reading corrupted or invalid snappy stream
	{
		corruptedStream := []byte{0x73, 0x4e, 0x61, 0x50, 0x70, 0x59, 0x00, 0x00, 0x00}
		srBad := snappy.NewReader(bytes.NewReader(corruptedStream))
		_, err := io.ReadAll(srBad)
		if err == nil {
			fmt.Fprintf(os.Stderr, "expected error reading corrupted stream, got nil\n")
			os.Exit(1)
		}
	}

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