github.com/klauspost/compress v1.20.0: s2.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 s2.NewReader 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:
  - s2.NewReader

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:b1cae593edf4df8dcce78ef191af38add3c474fc7d9c78283f8042bb38f63665","contract":["s2.NewReader decompresses framed S2 stream matching original uncompressed data","s2.Reader.ReadByte reads single bytes sequentially from decompressed stream","s2.Reader.Skip advances past specified number of uncompressed bytes","s2.Reader.Reset switches underlying reader source and resets decompression state","s2.Reader returns an error when reading corrupted or invalid stream","s2.NewReader with ReaderIgnoreCRC decompresses stream without error"],"goal":"verify s2.NewReader 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":["s2.NewReader"]},"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":["s2.NewReader"],"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/s2"
)

func main() {
	original := []byte("Hello, S2 streaming compression with klauspost/compress!")

	// Compress data into a buffer
	var compressed bytes.Buffer
	writer := s2.NewWriter(&compressed)
	if _, err := writer.Write(original); err != nil {
		log.Fatalf("failed to compress: %v", err)
	}
	if err := writer.Close(); err != nil {
		log.Fatalf("failed to close writer: %v", err)
	}

	// Decompress using s2.NewReader
	reader := s2.NewReader(&compressed)
	decompressed, err := io.ReadAll(reader)
	if err != nil {
		log.Fatalf("failed to decompress: %v", err)
	}

	fmt.Printf("Original:     %s\n", string(original))
	fmt.Printf("Decompressed: %s\n", string(decompressed))
}

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

package main

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

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

func compressBytes(data []byte) ([]byte, error) {
	var buf bytes.Buffer
	w := s2.NewWriter(&buf)
	if _, err := w.Write(data); err != nil {
		return nil, err
	}
	if err := w.Close(); err != nil {
		return nil, err
	}
	return buf.Bytes(), nil
}

func main() {
	// 1. s2.NewReader decompresses framed S2 stream matching original uncompressed data
	payload := []byte("The quick brown fox jumps over the lazy dog. 1234567890!")
	compressed, err := compressBytes(payload)
	if err != nil {
		fmt.Fprintf(os.Stderr, "failed to compress payload: %v\n", err)
		os.Exit(1)
	}

	r := s2.NewReader(bytes.NewReader(compressed))
	if r == nil {
		fmt.Fprintf(os.Stderr, "expected non-nil s2.Reader\n")
		os.Exit(1)
	}
	decompressed, err := io.ReadAll(r)
	if err != nil {
		fmt.Fprintf(os.Stderr, "failed to read all decompressed data: %v\n", err)
		os.Exit(1)
	}
	if !bytes.Equal(decompressed, payload) {
		fmt.Fprintf(os.Stderr, "decompressed payload mismatch: got %q, expected %q\n", decompressed, payload)
		os.Exit(1)
	}

	// 2. s2.Reader.ReadByte reads single bytes sequentially from decompressed stream
	r2 := s2.NewReader(bytes.NewReader(compressed))
	firstByte, err := r2.ReadByte()
	if err != nil {
		fmt.Fprintf(os.Stderr, "failed to ReadByte: %v\n", err)
		os.Exit(1)
	}
	if firstByte != payload[0] {
		fmt.Fprintf(os.Stderr, "ReadByte mismatch: got %c, expected %c\n", firstByte, payload[0])
		os.Exit(1)
	}
	secondByte, err := r2.ReadByte()
	if err != nil {
		fmt.Fprintf(os.Stderr, "failed to ReadByte (2nd): %v\n", err)
		os.Exit(1)
	}
	if secondByte != payload[1] {
		fmt.Fprintf(os.Stderr, "ReadByte 2nd mismatch: got %c, expected %c\n", secondByte, payload[1])
		os.Exit(1)
	}

	// 3. s2.Reader.Skip advances past specified number of uncompressed bytes
	r3 := s2.NewReader(bytes.NewReader(compressed))
	skipCount := int64(10)
	if err := r3.Skip(skipCount); err != nil {
		fmt.Fprintf(os.Stderr, "failed to Skip: %v\n", err)
		os.Exit(1)
	}
	remainder, err := io.ReadAll(r3)
	if err != nil {
		fmt.Fprintf(os.Stderr, "failed to read after Skip: %v\n", err)
		os.Exit(1)
	}
	if !bytes.Equal(remainder, payload[skipCount:]) {
		fmt.Fprintf(os.Stderr, "Skip mismatch: got %q, expected %q\n", remainder, payload[skipCount:])
		os.Exit(1)
	}

	// 4. s2.Reader.Reset switches underlying reader source and resets decompression state
	r4 := s2.NewReader(bytes.NewReader(compressed))
	_, _ = io.ReadAll(r4)

	secondPayload := []byte("Second stream payload for s2.Reader.Reset verification.")
	secondCompressed, err := compressBytes(secondPayload)
	if err != nil {
		fmt.Fprintf(os.Stderr, "failed to compress second payload: %v\n", err)
		os.Exit(1)
	}
	r4.Reset(bytes.NewReader(secondCompressed))
	secondDecompressed, err := io.ReadAll(r4)
	if err != nil {
		fmt.Fprintf(os.Stderr, "failed to read after Reset: %v\n", err)
		os.Exit(1)
	}
	if !bytes.Equal(secondDecompressed, secondPayload) {
		fmt.Fprintf(os.Stderr, "Reset payload mismatch: got %q, expected %q\n", secondDecompressed, secondPayload)
		os.Exit(1)
	}

	// 5. s2.Reader returns an error when reading corrupted or invalid stream
	corruptData := make([]byte, len(compressed))
	copy(corruptData, compressed)
	// corrupt header and payload bytes
	for i := range corruptData {
		corruptData[i] ^= 0xFF
	}
	rCorrupt := s2.NewReader(bytes.NewReader(corruptData))
	_, errCorrupt := io.ReadAll(rCorrupt)
	if errCorrupt == nil {
		fmt.Fprintf(os.Stderr, "expected error reading corrupted stream, got nil\n")
		os.Exit(1)
	}

	// 6. s2.NewReader with ReaderIgnoreCRC decompresses stream without error
	rIgnoreCRC := s2.NewReader(bytes.NewReader(compressed), s2.ReaderIgnoreCRC())
	decompressedNoCRC, err := io.ReadAll(rIgnoreCRC)
	if err != nil {
		fmt.Fprintf(os.Stderr, "failed to read with ReaderIgnoreCRC: %v\n", err)
		os.Exit(1)
	}
	if !bytes.Equal(decompressedNoCRC, payload) {
		fmt.Fprintf(os.Stderr, "ReaderIgnoreCRC mismatch: got %q, expected %q\n", decompressedNoCRC, payload)
		os.Exit(1)
	}

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