// on explicit reads + seeks provided by bio.Reader if needed.

type MReader struct {
	f        *os.File
	rdr      *bio.Reader
	fileView []byte
	off      int64
}

func NewMreader(f *os.File) (*MReader, error) {
	rdr := bio.NewReader(f)
	fi, err := f.Stat()
	if err != nil {
		return nil, err
	}
	r := MReader{
		f:        f,
		rdr:      rdr,
		fileView: rdr.SliceRO(uint64(fi.Size())),
	}
	return &r, nil

		cf, err := os.Open(cdf)
		if err != nil {
			return r.fatal("opening counter data file %s: %s", cdf, err)
		}
		defer func(f *os.File) {
			f.Close()
		}(cf)
		var mr *MReader
		mr, err = NewMreader(cf)
		if err != nil {
			return r.fatal("creating reader for counter data file %s: %s", cdf, err)
		}
		var cdr *decodecounter.CounterDataReader
		cdr, err = decodecounter.NewCounterDataReader(cdf, mr)

		success           bool
	}{
		{
			desc:       "Invalid md5sum NewReader() will fail.",
			src:        bytes.NewReader([]byte("abcd")),
			size:       4,
			actualSize: 4,
			md5hex:     "invalid-md5",
			success:    false,
		},
		{
			desc:       "Invalid sha256 NewReader() will fail.",
			src:        bytes.NewReader([]byte("abcd")),
			size:       4,
			actualSize: 4,

	// Determine the uncompressed size of testfile.
	uncompressedSize, err := io.Copy(io.Discard, NewReader(bytes.NewReader(compressed)))
	if err != nil {
		b.Fatal(err)
	}

	b.SetBytes(uncompressedSize)
	b.ReportAllocs()
	b.ResetTimer()

	for i := 0; i < b.N; i++ {
		r := bytes.NewReader(compressed)
		io.Copy(io.Discard, NewReader(r))
	}
}

func BenchmarkDecodeDigits(b *testing.B) { benchmarkDecode(b, digits) }

}

func ExampleLimitReader() {
	r := strings.NewReader("some io.Reader stream to be read\n")
	lr := io.LimitReader(r, 4)

	if _, err := io.Copy(os.Stdout, lr); err != nil {
		log.Fatal(err)
	}

	// Output:
	// some
}

func ExampleMultiReader() {
	r1 := strings.NewReader("first reader ")
	r2 := strings.NewReader("second reader ")
	r3 := strings.NewReader("third reader\n")
	r := io.MultiReader(r1, r2, r3)

		_, err := ReadData(bytes.NewReader(input), 1<<62)
		if err == nil {
			t.Error("large read succeeded unexpectedly")
		}
	})

	t.Run("small-EOF", func(t *testing.T) {
		_, err := ReadData(bytes.NewReader(nil), chunk-1)
		if err != io.EOF {
			t.Errorf("ReadData = %v, want io.EOF", err)
		}
	})

	t.Run("large-EOF", func(t *testing.T) {
		_, err := ReadData(bytes.NewReader(nil), chunk+1)
		if err != io.EOF {

		{"\x02", ""},
		{"\xf2H\xcd", "He"},
		{"\xf2H͙0a\u0084\t", "Hel\x90\x90\x90\x90\x90"},
		{"\xf2H͙0a\u0084\t\x00", "Hel\x90\x90\x90\x90\x90"},
	}

	for i, v := range vectors {
		r := strings.NewReader(v.input)
		zr := NewReader(r)
		b, err := io.ReadAll(zr)
		if err != io.ErrUnexpectedEOF {
			t.Errorf("test %d, error mismatch: got %v, want io.ErrUnexpectedEOF", i, err)
		}
		if string(b) != v.output {

		chunkSignature []byte
	}
	// List of readers used.
	readers := []io.Reader{
		// Test - 1
		bytes.NewReader([]byte("1000;chunk-signature=111123333333333333334444211\r\n")),
		// Test - 2
		bytes.NewReader([]byte("1000;")),
		// Test - 3
		bytes.NewReader([]byte(fmt.Sprintf("%4097d", 1))),
		// Test - 4
		bytes.NewReader([]byte("1000;chunk-signature=111123333333333333334444211\r\n")),
	}
	testCases := []testCase{

	r := NewDocumentDecoder(io.NopCloser(bytes.NewReader([]byte(dd[:maxLen-1]))))
	b := make([]byte, bufferLen)
	n, err := r.Read(b)
	if err != io.ErrShortBuffer {
		t.Fatalf("expected ErrShortBuffer: %d / %v", n, err)
	}
	b = make([]byte, maxLen)
	n, err = r.Read(b)
	if err != nil {
		t.Fatalf("expected nil: %d / %v", n, err)
	}
	r = NewDocumentDecoder(io.NopCloser(bytes.NewReader([]byte(dd))))
	b = make([]byte, maxLen)

	bf := bufio.NewReader(r)
	switch f := detect(bf); f {
	case formatGzip:
		gz, err := gzip.NewReader(bf)
		if err != nil {
			return err
		}
		defer gz.Close()
		r = gz
	case formatS2:
		r = s2.NewReader(bf)
	case formatZstd:
		// Limit to 16 MiB per stream.
		dec, err := zstd.NewReader(bf, zstd.WithDecoderMaxWindow(16<<20))
		if err != nil {