github.com/klauspost/compress v1.20.0: s2.NewWriter

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.NewWriter 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.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:155c8cc1d3fc7468e869cf66b697deecba13d091ac7de9ebdef09cc7d5e51375","contract":["s2.NewWriter compresses byte stream into framed S2 format readable by s2.NewReader","s2.Writer.Flush flushes buffered compressed frames to underlying writer","s2.Writer.Reset reinitializes writer destination and resets compression state","s2.Writer.ReadFrom reads uncompressed stream from reader and compresses to destination","s2.Writer returns an error when writing to closed writer","s2.NewWriter with WriterBetterCompression produces valid compressed stream","s2.NewWriter with WriterSnappyCompat produces stream readable by s2.NewReader"],"goal":"verify s2.NewWriter 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.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":["s2.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/s2"
)

func main() {
	original := []byte("Hello, S2 streaming compression with s2.NewWriter!")

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

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

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

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

package main

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

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

func main() {
	// 1. s2.NewWriter compresses byte stream into framed S2 format readable by s2.NewReader
	payload := []byte("Contract test payload for S2 stream compression verification.")
	var buf1 bytes.Buffer
	w1 := s2.NewWriter(&buf1)
	if w1 == nil {
		fmt.Fprintf(os.Stderr, "expected non-nil s2.Writer\n")
		os.Exit(1)
	}
	n1, err := w1.Write(payload)
	if err != nil || n1 != len(payload) {
		fmt.Fprintf(os.Stderr, "w1.Write failed: %v, wrote %d\n", err, n1)
		os.Exit(1)
	}
	if err := w1.Close(); err != nil {
		fmt.Fprintf(os.Stderr, "w1.Close failed: %v\n", err)
		os.Exit(1)
	}
	r1 := s2.NewReader(&buf1)
	decompressed1, err := io.ReadAll(r1)
	if err != nil || !bytes.Equal(decompressed1, payload) {
		fmt.Fprintf(os.Stderr, "decompression mismatch: %v, got %q, expected %q\n", err, decompressed1, payload)
		os.Exit(1)
	}

	// 2. s2.Writer.Flush flushes buffered compressed frames to underlying writer
	var buf2 bytes.Buffer
	w2 := s2.NewWriter(&buf2)
	chunk := []byte("flush test chunk before closing")
	if _, err := w2.Write(chunk); err != nil {
		fmt.Fprintf(os.Stderr, "w2.Write failed: %v\n", err)
		os.Exit(1)
	}
	if err := w2.Flush(); err != nil {
		fmt.Fprintf(os.Stderr, "w2.Flush failed: %v\n", err)
		os.Exit(1)
	}
	if buf2.Len() == 0 {
		fmt.Fprintf(os.Stderr, "expected buffer to contain flushed bytes, got 0 length\n")
		os.Exit(1)
	}
	if err := w2.Close(); err != nil {
		fmt.Fprintf(os.Stderr, "w2.Close failed: %v\n", err)
		os.Exit(1)
	}
	r2 := s2.NewReader(&buf2)
	decompressed2, err := io.ReadAll(r2)
	if err != nil || !bytes.Equal(decompressed2, chunk) {
		fmt.Fprintf(os.Stderr, "flush decompression mismatch: %v\n", err)
		os.Exit(1)
	}

	// 3. s2.Writer.Reset reinitializes writer destination and resets compression state
	var buf3 bytes.Buffer
	w2.Reset(&buf3)
	resetPayload := []byte("payload written after Reset onto a fresh destination buffer")
	if _, err := w2.Write(resetPayload); err != nil {
		fmt.Fprintf(os.Stderr, "w2.Write after Reset failed: %v\n", err)
		os.Exit(1)
	}
	if err := w2.Close(); err != nil {
		fmt.Fprintf(os.Stderr, "w2.Close after Reset failed: %v\n", err)
		os.Exit(1)
	}
	r3 := s2.NewReader(&buf3)
	decompressed3, err := io.ReadAll(r3)
	if err != nil || !bytes.Equal(decompressed3, resetPayload) {
		fmt.Fprintf(os.Stderr, "reset decompression mismatch: %v\n", err)
		os.Exit(1)
	}

	// 4. s2.Writer.ReadFrom reads uncompressed stream from reader and compresses to destination
	var buf4 bytes.Buffer
	w4 := s2.NewWriter(&buf4)
	streamText := strings.Repeat("stream data reading from an io.Reader source; ", 20)
	nRead, err := w4.ReadFrom(strings.NewReader(streamText))
	if err != nil || nRead != int64(len(streamText)) {
		fmt.Fprintf(os.Stderr, "w4.ReadFrom failed: %v, read %d\n", err, nRead)
		os.Exit(1)
	}
	if err := w4.Close(); err != nil {
		fmt.Fprintf(os.Stderr, "w4.Close failed: %v\n", err)
		os.Exit(1)
	}
	r4 := s2.NewReader(&buf4)
	decompressed4, err := io.ReadAll(r4)
	if err != nil || string(decompressed4) != streamText {
		fmt.Fprintf(os.Stderr, "readFrom decompression mismatch: %v\n", err)
		os.Exit(1)
	}

	// 5. s2.Writer returns an error when writing to closed writer
	var buf5 bytes.Buffer
	w5 := s2.NewWriter(&buf5)
	if _, err := w5.Write([]byte("initial")); err != nil {
		fmt.Fprintf(os.Stderr, "w5.Write failed: %v\n", err)
		os.Exit(1)
	}
	if err := w5.Close(); err != nil {
		fmt.Fprintf(os.Stderr, "w5.Close failed: %v\n", err)
		os.Exit(1)
	}
	if _, err := w5.Write([]byte("after close")); err == nil {
		fmt.Fprintf(os.Stderr, "expected error writing to closed writer, got nil\n")
		os.Exit(1)
	}

	// 6. s2.NewWriter with WriterBetterCompression produces valid compressed stream
	var buf6 bytes.Buffer
	w6 := s2.NewWriter(&buf6, s2.WriterBetterCompression())
	betterPayload := []byte("compressing with WriterBetterCompression enabled")
	if _, err := w6.Write(betterPayload); err != nil {
		fmt.Fprintf(os.Stderr, "w6.Write failed: %v\n", err)
		os.Exit(1)
	}
	if err := w6.Close(); err != nil {
		fmt.Fprintf(os.Stderr, "w6.Close failed: %v\n", err)
		os.Exit(1)
	}
	r6 := s2.NewReader(&buf6)
	decompressed6, err := io.ReadAll(r6)
	if err != nil || !bytes.Equal(decompressed6, betterPayload) {
		fmt.Fprintf(os.Stderr, "better compression mismatch: %v\n", err)
		os.Exit(1)
	}

	// 7. s2.NewWriter with WriterSnappyCompat produces stream readable by s2.NewReader
	var buf7 bytes.Buffer
	w7 := s2.NewWriter(&buf7, s2.WriterSnappyCompat())
	snappyPayload := []byte("snappy compatibility mode payload verification")
	if _, err := w7.Write(snappyPayload); err != nil {
		fmt.Fprintf(os.Stderr, "w7.Write failed: %v\n", err)
		os.Exit(1)
	}
	if err := w7.Close(); err != nil {
		fmt.Fprintf(os.Stderr, "w7.Close failed: %v\n", err)
		os.Exit(1)
	}
	r7 := s2.NewReader(&buf7)
	decompressed7, err := io.ReadAll(r7)
	if err != nil || !bytes.Equal(decompressed7, snappyPayload) {
		fmt.Fprintf(os.Stderr, "snappy compat mismatch: %v\n", err)
		os.Exit(1)
	}

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