Function TestDecryptReaderAt

internal/stream/stream_test.go:202–412

(t *testing.T)

}

func TestDecryptReaderAt(t *testing.T) {
	key := make([]byte, chacha20poly1305.KeySize)
	if _, err := rand.Read(key); err != nil {
		t.Fatal(err)
	}

	// Create plaintext spanning exactly 3 chunks: 2 full chunks + partial third
	// Chunk 0: [0, cs)
	// Chunk 1: [cs, 2*cs)
	// Chunk 2: [2*cs, 2*cs+500)
	plaintextSize := 2*cs + 500
	plaintext := make([]byte, plaintextSize)
	if _, err := rand.Read(plaintext); err != nil {
		t.Fatal(err)
	}

	// Encrypt
	buf := &bytes.Buffer{}
	w, err := stream.NewEncryptWriter(key, buf)
	if err != nil {
		t.Fatal(err)
	}
	if _, err := w.Write(plaintext); err != nil {
		t.Fatal(err)
	}
	if err := w.Close(); err != nil {
		t.Fatal(err)
	}
	ciphertext := buf.Bytes()

	// Create tracking ReaderAt
	tracker := &trackingReaderAt{r: bytes.NewReader(ciphertext)}

	// Create DecryptReaderAt (this reads and caches the final chunk)
	ra, err := stream.NewDecryptReaderAt(key, tracker, int64(len(ciphertext)))
	if err != nil {
		t.Fatal(err)
	}
	tracker.reset()

	// Helper to check reads
	checkRead := func(name string, off int64, size int, wantN int, wantEOF bool, wantSrcRead bool) {
		t.Helper()
		tracker.reset()
		p := make([]byte, size)
		n, err := ra.ReadAt(p, off)

		if wantEOF {
			if err != io.EOF {
				t.Errorf("%s: got err=%v, want EOF", name, err)
			}
		} else {
			if err != nil {
				t.Errorf("%s: got err=%v, want nil", name, err)
			}
		}

		if n != wantN {