riegeli 0.1.2

Rust implementation of the Riegeli/records file format
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! Integration tests for file padding alignment and padded-file concatenation.
use std::io::Cursor;

use riegeli::{
    CompressionType, ReaderOptions, RecordReader, RecordWriter, RiegeliError, WriterOptions,
};

/// Write records to a Vec<u8> and return the bytes.
fn write_records(records: &[&[u8]], opts: WriterOptions) -> Vec<u8> {
    let mut cursor = Cursor::new(Vec::<u8>::new());
    {
        let mut w = RecordWriter::new(&mut cursor, opts).expect("writer::new");
        for rec in records {
            w.write_record(rec).expect("write_record");
        }
        w.flush().expect("flush");
    }
    cursor.into_inner()
}

/// Read all records from a byte slice.
fn read_all(data: Vec<u8>) -> Vec<Vec<u8>> {
    let mut reader =
        RecordReader::new(Cursor::new(data), ReaderOptions::new()).expect("reader::new");
    let mut records = Vec::new();
    while let Some(rec) = reader.read_record().expect("read_record") {
        records.push(rec);
    }
    records
}

// Block size constant for padding assertions (matches the wire format spec).
const BLOCK_SIZE: u64 = 65536;

// -----------------------------------------------------------------------
// Criterion 7.2: initial_padding(65536) produces file_size % 65536 == 0
// -----------------------------------------------------------------------

#[test]
fn initial_padding_aligns_empty_file() {
    let data = write_records(&[], WriterOptions::new().initial_padding(BLOCK_SIZE));
    assert_eq!(
        data.len() as u64 % BLOCK_SIZE,
        0,
        "empty file with initial_padding({BLOCK_SIZE}) must have size % {BLOCK_SIZE} == 0, got {}",
        data.len()
    );
}

#[test]
fn initial_padding_aligns_small_file() {
    let data = write_records(
        &[b"hello", b"world"],
        WriterOptions::new().initial_padding(BLOCK_SIZE),
    );
    assert_eq!(
        data.len() as u64 % BLOCK_SIZE,
        0,
        "small file with initial_padding({BLOCK_SIZE}) must have size % {BLOCK_SIZE} == 0, got {}",
        data.len()
    );
}

#[test]
fn initial_padding_aligns_multi_block_file() {
    // Write enough data to span multiple blocks.
    let record: Vec<u8> = vec![0xAB; 1000];
    let records: Vec<&[u8]> = (0..300).map(|_| record.as_slice()).collect();
    let data = write_records(&records, WriterOptions::new().initial_padding(BLOCK_SIZE));
    assert_eq!(
        data.len() as u64 % BLOCK_SIZE,
        0,
        "multi-block file with initial_padding({BLOCK_SIZE}) must have size % {BLOCK_SIZE} == 0, got {}",
        data.len()
    );
    // Verify records are still readable.
    let got = read_all(data);
    assert_eq!(got.len(), 300);
    for (i, rec) in got.iter().enumerate() {
        assert_eq!(rec.as_slice(), record.as_slice(), "record {i} mismatch");
    }
}

// -----------------------------------------------------------------------
// Criterion 7.3: two padded files can be concatenated and read as one
// -----------------------------------------------------------------------

#[test]
fn concatenated_padded_files_readable() {
    let records_a: &[&[u8]] = &[b"file_a_rec1", b"file_a_rec2", b"file_a_rec3"];
    let records_b: &[&[u8]] = &[b"file_b_rec1", b"file_b_rec2"];

    let opts = WriterOptions::new().initial_padding(BLOCK_SIZE);
    let file_a = write_records(records_a, opts.clone());
    let file_b = write_records(records_b, opts);

    // Both files must be block-aligned.
    assert_eq!(
        file_a.len() as u64 % BLOCK_SIZE,
        0,
        "file_a not block-aligned"
    );
    assert_eq!(
        file_b.len() as u64 % BLOCK_SIZE,
        0,
        "file_b not block-aligned"
    );

    // Concatenate at byte level.
    let mut combined = file_a;
    combined.extend_from_slice(&file_b);

    // Read all records from the concatenated file.
    let got = read_all(combined);

    // Should contain records from both files.
    let expected: Vec<&[u8]> = records_a.iter().chain(records_b.iter()).copied().collect();
    assert_eq!(
        got.len(),
        expected.len(),
        "concatenated file: expected {} records, got {}",
        expected.len(),
        got.len()
    );
    for (i, (expected_rec, got_rec)) in expected.iter().zip(got.iter()).enumerate() {
        assert_eq!(
            got_rec.as_slice(),
            *expected_rec,
            "record {i} mismatch in concatenated file"
        );
    }
}

// -----------------------------------------------------------------------
// Criterion 7.4: TryFrom<u8> for CompressionType (public API)
// -----------------------------------------------------------------------

#[test]
fn compression_type_try_from_unknown_returns_err() {
    let unknown_bytes: &[u8] = &[0x01, 0x7f, 0xfe, 0xff, b'x', b'r'];
    for &b in unknown_bytes {
        let result = CompressionType::try_from(b);
        assert!(
            matches!(result, Err(RiegeliError::UnknownCompressionType(_))),
            "expected UnknownCompressionType for byte {b:#04x}, got {result:?}"
        );
    }
}