script/rac-random-seek-test.go

// Copyright 2019 The Wuffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//    https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

//go:build ignore
// +build ignore

package main

// rac-random-seek-test.go compresses stdin to the RAC file format, then checks
// that repeatedly randomly accessing that RAC file recovers the original input.
//
// Usage: go run rac-random-seek-test.go < input

import (
	"bytes"
	"fmt"
	"io"
	"math/rand"
	"os"

	"github.com/google/wuffs/lib/rac"
	"github.com/google/wuffs/lib/raczlib"
)

func main() {
	if err := main1(); err != nil {
		os.Stderr.WriteString(err.Error() + "\n")
		os.Exit(1)
	}
}

func main1() error {
	input, err := io.ReadAll(os.Stdin)
	if err != nil {
		return err
	}
	buf := &bytes.Buffer{}
	const dChunkSize = 256
	w := &rac.Writer{
		Writer:      buf,
		CodecWriter: &raczlib.CodecWriter{},
		DChunkSize:  dChunkSize,
	}
	if _, err := w.Write(input); err != nil {
		return err
	}
	if err := w.Close(); err != nil {
		return err
	}
	compressed := buf.Bytes()
	r := &rac.Reader{
		ReadSeeker:     bytes.NewReader(compressed),
		CompressedSize: int64(buf.Len()),
		CodecReaders:   []rac.CodecReader{&raczlib.CodecReader{}},
	}
	numChunks, err := countRACChunks(compressed)
	if err != nil {
		return err
	}
	if want := (len(input) + dChunkSize - 1) / dChunkSize; numChunks != want {
		return fmt.Errorf("numChunks: got %d, want %d", numChunks, want)
	}

	fmt.Printf("%8d uncompressed bytes\n", len(input))
	fmt.Printf("%8d   compressed bytes\n", len(compressed))
	fmt.Printf("%8d          RAC chunks\n", numChunks)

	got := make([]byte, len(input))
	if _, err := io.ReadFull(r, got); err != nil {
		return fmt.Errorf("ReadFull: %v", err)
	} else if !bytes.Equal(got, input) {
		return fmt.Errorf("ReadFull: mismatch")
	}

	for i, rng := uint64(0), rand.New(rand.NewSource(1)); ; i++ {
		m := rng.Intn(len(input) + 1)
		n := rng.Intn(len(input) + 1)
		if m > n {
			m, n = n, m
		}

		got = got[:n-m]
		if _, err := r.Seek(int64(m), io.SeekStart); err != nil {
			return fmt.Errorf("i=%d, m=%d, n=%d: Seek: %v", i, m, n, err)
		}
		if _, err := io.ReadFull(r, got); err != nil {
			return fmt.Errorf("i=%d, m=%d, n=%d: ReadFull: %v", i, m, n, err)
		}

		want := input[m:n]
		if !bytes.Equal(got, want) {
			return fmt.Errorf("i=%d, m=%d, n=%d: mismatch", i, m, n)
		}

		if i%1024 == 0 {
			fmt.Printf("i=%d: ok\n", i)
		}
	}
}

func countRACChunks(compressed []byte) (int, error) {
	r := &rac.ChunkReader{
		ReadSeeker:     bytes.NewReader(compressed),
		CompressedSize: int64(len(compressed)),
	}
	for n := 0; ; n++ {
		if _, err := r.NextChunk(); err == io.EOF {
			return n, nil
		} else if err != nil {
			return 0, err
		}
	}
}