github.com/klauspost/compress v1.12.3: compress and decompress data using s2 streaming encoder and decoder

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: compress and decompress data using s2 streaming encoder and decoder in pkg:golang/github.com/klauspost/compress@v1.12.3
Kind: HOW

Use EXACTLY these public packages and versions:
  - pkg:golang/github.com/klauspost/compress@v1.12.3
Demonstrate these symbols/APIs:
  - github.com/klauspost/compress/s2.NewReader
  - github.com/klauspost/compress/s2.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.

package sample

import (
	"bytes"
	"strings"
	"testing"

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

func TestS2CompressAndDecompressValidStream(t *testing.T) {
	original := []byte("CodeSampleX verification payload for github.com/klauspost/compress/s2 streaming compression.")

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

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

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

func TestS2RoundtripEmptyPayload(t *testing.T) {
	original := []byte("")

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

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

	if len(decompressed) != 0 {
		t.Fatalf("Expected empty decompressed payload, got %d bytes", len(decompressed))
	}
}

func TestS2CorruptedStreamError(t *testing.T) {
	corrupted := []byte{0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc}

	_, err := DecompressBytes(corrupted)
	if err == nil {
		t.Fatalf("expected error reading corrupted s2 stream, got nil")
	}
}

func TestS2WriterOptionsAndReset(t *testing.T) {
	payload1 := []byte(strings.Repeat("First stream payload with repeated patterns for better compression ratio. ", 20))
	payload2 := []byte("Second stream payload compressed after resetting the writer.")

	var buf1 bytes.Buffer
	writer := s2.NewWriter(&buf1, s2.WriterBetterCompression(), s2.WriterBlockSize(64*1024))
	if _, err := writer.Write(payload1); err != nil {
		t.Fatalf("writer.Write payload1 failed: %v", err)
	}
	if err := writer.Close(); err != nil {
		t.Fatalf("writer.Close payload1 failed: %v", err)
	}

	var buf2 bytes.Buffer
	writer.Reset(&buf2)
	if _, err := writer.Write(payload2); err != nil {
		t.Fatalf("writer.Write payload2 failed: %v", err)
	}
	if err := writer.Close(); err != nil {
		t.Fatalf("writer.Close payload2 failed: %v", err)
	}

	out1, err := DecompressBytes(buf1.Bytes())
	if err != nil {
		t.Fatalf("DecompressBytes payload1 failed: %v", err)
	}
	if !bytes.Equal(payload1, out1) {
		t.Fatalf("payload1 mismatch: got %q, want %q", string(out1), string(payload1))
	}

	out2, err := DecompressBytes(buf2.Bytes())
	if err != nil {
		t.Fatalf("DecompressBytes payload2 failed: %v", err)
	}
	if !bytes.Equal(payload2, out2) {
		t.Fatalf("payload2 mismatch: got %q, want %q", string(out2), string(payload2))
	}
}

{"case":{"caseId":"case:sha256:2c98b7fbee7c9d9e2b96a7ebbbe98430bdfd9802845671c4a00e9c25a54c6e18","contract":["s2.NewWriter compresses data stream and s2.NewReader decompresses and restores exact original payload","s2.NewWriter and s2.NewReader correctly roundtrip empty input payload","s2.NewReader returns error when reading corrupted or invalid stream","s2.NewWriter supports encoder options and stream resetting"],"goal":"compress and decompress data using s2 streaming encoder and decoder in pkg:golang/github.com/klauspost/compress@v1.12.3","kind":"HOW","packages":["pkg:golang/github.com/klauspost/compress@v1.12.3"],"schemaVersion":1,"symbols":["github.com/klauspost/compress/s2.NewReader","github.com/klauspost/compress/s2.NewWriter"]},"contractCommand":["go","test","-v","./..."],"environment":{"arch":"amd64","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.12.3"],"schemaVersion":1,"subject":"pkg:golang/github.com/klauspost/compress@v1.12.3","symbols":["github.com/klauspost/compress/s2.NewReader","github.com/klauspost/compress/s2.NewWriter"],"verifierAdapter":"golang@1"}

module example.com/s2-sample

go 1.26

require github.com/klauspost/compress v1.12.3

github.com/golang/snappy v0.0.3/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
github.com/klauspost/compress v1.12.3 h1:G5AfA94pHPysR56qqrkO2pxEexdDzrpFJ6yt/VqWxVU=
github.com/klauspost/compress v1.12.3/go.mod h1:8dP1Hq4DHOhN9w426knH3Rhby4rFm6D8eO+e+Dq5Gzg=

package sample

import (
	"bytes"
	"fmt"
	"io"

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

// CompressStream writes compressed data from src to dst using s2.NewWriter.
func CompressStream(dst io.Writer, src io.Reader, opts ...s2.WriterOption) error {
	writer := s2.NewWriter(dst, opts...)
	if _, err := io.Copy(writer, src); err != nil {
		_ = writer.Close()
		return fmt.Errorf("s2 write: %w", err)
	}
	if err := writer.Close(); err != nil {
		return fmt.Errorf("s2 close: %w", err)
	}
	return nil
}

// CompressBytes compresses a byte slice using s2.NewWriter.
func CompressBytes(src []byte, opts ...s2.WriterOption) ([]byte, error) {
	var buf bytes.Buffer
	writer := s2.NewWriter(&buf, opts...)
	if _, err := writer.Write(src); err != nil {
		_ = writer.Close()
		return nil, fmt.Errorf("s2 write: %w", err)
	}
	if err := writer.Close(); err != nil {
		return nil, fmt.Errorf("s2 close: %w", err)
	}
	return buf.Bytes(), nil
}

// DecompressStream reads compressed data from src and writes decompressed data to dst using s2.NewReader.
func DecompressStream(dst io.Writer, src io.Reader, opts ...s2.ReaderOption) error {
	reader := s2.NewReader(src, opts...)
	if _, err := io.Copy(dst, reader); err != nil {
		return fmt.Errorf("s2 read: %w", err)
	}
	return nil
}

// DecompressBytes decompresses a byte slice using s2.NewReader.
func DecompressBytes(compressed []byte, opts ...s2.ReaderOption) ([]byte, error) {
	reader := s2.NewReader(bytes.NewReader(compressed), opts...)
	decompressed, err := io.ReadAll(reader)
	if err != nil {
		return nil, fmt.Errorf("s2 read all: %w", err)
	}
	return decompressed, nil
}

{
  "schemaVersion": 1,
  "goal": "compress and decompress data using s2 streaming encoder and decoder in pkg:golang/github.com/klauspost/compress@v1.12.3",
  "kind": "HOW",
  "packages": [
    "pkg:golang/github.com/klauspost/compress@v1.12.3"
  ],
  "symbols": [
    "github.com/klauspost/compress/s2.NewReader",
    "github.com/klauspost/compress/s2.NewWriter"
  ]
}