Skip to content

Commit f8733d2

Browse files
nyuriknyurik
committed
cleanup
1 parent ee9568b commit f8733d2

3 files changed

Lines changed: 42 additions & 78 deletions

File tree

‎src/rust/integer_compression/fastpfor.rs‎

Lines changed: 1 addition & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -706,9 +706,7 @@ mod tests {
706706
fn decode_index1_branch_valid() {
707707
let mut data = vec![1u32; 256];
708708
data[0] = 3;
709-
let compressed = block_compress::<FastPForBlock256>(&data).unwrap();
710-
let out = block_decompress::<FastPForBlock256>(&compressed, Some(256)).unwrap();
711-
assert_eq!(out, data);
709+
block_roundtrip::<FastPForBlock256>(&data);
712710
}
713711

714712
/// `decode_blocks` with `expected_len: None` and header=0 returns `Ok` with empty output.

‎src/test_utils.rs‎

Lines changed: 30 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -31,20 +31,43 @@ const SEED: u64 = 456;
3131
// Generic codec helpers
3232
// ---------------------------------------------------------------------------
3333

34+
pub fn roundtrip<C: AnyLenCodec>(data: &[u32]) {
35+
roundtrip_expected::<C>(data, Some(data.len().try_into().unwrap()));
36+
}
37+
3438
/// Encode `data` with a caller-owned codec, decode with `expected_len: None`, assert round-trip.
35-
pub fn roundtrip_expected<C: AnyLenCodec>(data: &[u32], expected_len: Option<u32>) {
39+
pub fn roundtrip_expected<E: AnyLenCodec>(data: &[u32], expected_len: Option<u32>) {
40+
roundtrip_full::<E, E>(data, expected_len);
41+
}
42+
43+
/// Encode `data` with a caller-owned codec, decode with `expected_len: None`, assert round-trip.
44+
pub fn roundtrip_full<E: AnyLenCodec, D: AnyLenCodec>(data: &[u32], expected_len: Option<u32>) {
45+
let mut encoder = E::default();
46+
let mut compressed = Vec::new();
47+
encoder.encode(data, &mut compressed).unwrap();
48+
49+
let mut decoder = D::default();
50+
let mut decompressed = Vec::new();
51+
decoder
52+
.decode(&compressed, &mut decompressed, expected_len)
53+
.unwrap();
54+
assert_eq!(decompressed, data);
55+
}
56+
57+
#[cfg(feature = "cpp")]
58+
pub fn roundtrip64<C: BlockCodec64 + Default>(data: &[u64]) {
3659
let mut codec = C::default();
3760
let mut compressed = Vec::new();
38-
codec.encode(data, &mut compressed).unwrap();
61+
codec.encode64(data, &mut compressed).unwrap();
3962
let mut decoded = Vec::new();
40-
codec
41-
.decode(&compressed, &mut decoded, expected_len)
42-
.unwrap();
63+
codec.decode64(&compressed, &mut decoded).unwrap();
4364
assert_eq!(decoded, data);
4465
}
4566

46-
pub fn roundtrip<C: AnyLenCodec>(data: &[u32]) {
47-
roundtrip_expected::<C>(data, Some(data.len().try_into().unwrap()));
67+
pub fn block_roundtrip<C: BlockCodec>(data: &[u32]) {
68+
let compressed = block_compress::<C>(data).unwrap();
69+
let decompressed = block_decompress::<C>(&compressed, Some(data.len() as u32)).unwrap();
70+
assert_eq!(decompressed, data);
4871
}
4972

5073
pub fn compress<C: AnyLenCodec>(data: &[u32]) -> FastPForResult<Vec<u32>> {
@@ -62,12 +85,6 @@ pub fn decompress<C: AnyLenCodec>(
6285
Ok(decompressed)
6386
}
6487

65-
pub fn block_roundtrip<C: BlockCodec>(data: &[u32]) {
66-
let compressed = block_compress::<C>(data).unwrap();
67-
let decompressed = block_decompress::<C>(&compressed, Some(data.len() as u32)).unwrap();
68-
assert_eq!(decompressed, data);
69-
}
70-
7188
pub fn block_compress<C: BlockCodec>(data: &[u32]) -> FastPForResult<Vec<u32>> {
7289
let (blocks, remainder) = slice_to_blocks::<C>(data);
7390
assert_eq!(
@@ -89,16 +106,6 @@ pub fn block_decompress<C: BlockCodec>(
89106
Ok(out)
90107
}
91108

92-
#[cfg(feature = "cpp")]
93-
pub fn roundtrip64<C: BlockCodec64 + Default>(data: &[u64]) {
94-
let mut codec = C::default();
95-
let mut compressed = Vec::new();
96-
codec.encode64(data, &mut compressed).unwrap();
97-
let mut decoded = Vec::new();
98-
codec.decode64(&compressed, &mut decoded).unwrap();
99-
assert_eq!(decoded, data);
100-
}
101-
102109
#[cfg(feature = "cpp")]
103110
pub fn compress64<C: BlockCodec64 + Default>(data: &[u64]) -> FastPForResult<Vec<u32>> {
104111
let mut compressed = Vec::new();

‎tests/cpp_compat_tests.rs‎

Lines changed: 11 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -9,39 +9,26 @@
99
mod test_utils;
1010

1111
use fastpfor::{FastPFor128, FastPFor256, FastPForBlock128};
12-
use test_utils::{block_compress, compress, decompress, roundtrip};
12+
use test_utils::{block_compress, block_decompress, compress, decompress, roundtrip};
1313

1414
mod common;
1515
use common::{get_test_cases, test_input_sizes};
1616
use fastpfor::cpp::CppFastPFor128;
17-
use fastpfor::{AnyLenCodec, BlockCodec, slice_to_blocks};
17+
18+
use crate::test_utils::roundtrip_full;
1819

1920
/// C++ `AnyLenCodec` encode → Rust `BlockCodec` decode (same wire format for block-aligned data).
2021
#[test]
2122
fn test_rust_decompresses_cpp_encoded_data() {
22-
let mut codec_cpp = CppFastPFor128::default();
23-
let mut codec_rs = FastPForBlock128::default();
24-
let mut cpp_compressed = Vec::new();
25-
2623
for n in test_input_sizes() {
2724
for input in get_test_cases(n + 128) {
2825
if input.len() % 128 != 0 || input.is_empty() {
2926
continue;
3027
}
31-
let n_blocks = input.len() / 128;
32-
33-
cpp_compressed.truncate(0);
34-
codec_cpp.encode(&input, &mut cpp_compressed).unwrap();
35-
36-
let mut rust_decoded = Vec::new();
37-
codec_rs
38-
.decode_blocks(
39-
&cpp_compressed,
40-
Some(u32::try_from(n_blocks * 128).expect("block count fits in u32")),
41-
&mut rust_decoded,
42-
)
43-
.unwrap_or_else(|e| panic!("Rust decompress of C++ data failed: {e:?}"));
44-
28+
let cpp_compressed = compress::<CppFastPFor128>(&input).unwrap();
29+
let rust_decoded =
30+
block_decompress::<FastPForBlock128>(&cpp_compressed, Some(input.len() as u32))
31+
.unwrap_or_else(|e| panic!("Rust decompress of C++ data failed: {e:?}"));
4532
assert_eq!(
4633
rust_decoded,
4734
input,
@@ -55,35 +42,14 @@ fn test_rust_decompresses_cpp_encoded_data() {
5542
/// Rust `BlockCodec` encode → C++ `AnyLenCodec` decode (same wire format).
5643
#[test]
5744
fn test_cpp_decompresses_rust_block_encoded_data() {
58-
let mut codec_cpp = CppFastPFor128::default();
59-
let mut codec_rs = FastPForBlock128::default();
60-
6145
for n in test_input_sizes() {
6246
for input in get_test_cases(n + 128) {
6347
if input.len() % 128 != 0 || input.is_empty() {
6448
continue;
6549
}
66-
let (blocks, _) = slice_to_blocks::<FastPForBlock128>(&input);
67-
let n_blocks = blocks.len();
68-
let expected_len = n_blocks * 128;
69-
70-
let mut rs_compressed = Vec::new();
71-
codec_rs.encode_blocks(blocks, &mut rs_compressed).unwrap();
72-
73-
let mut cpp_decoded = Vec::new();
74-
codec_cpp
75-
.decode(
76-
&rs_compressed,
77-
&mut cpp_decoded,
78-
Some(u32::try_from(expected_len).expect("expected len fits in u32")),
79-
)
80-
.unwrap_or_else(|e| panic!("C++ decompress of Rust data failed: {e:?}"));
81-
82-
assert_eq!(
83-
cpp_decoded,
84-
input,
85-
"Rust→C++ roundtrip mismatch for len {}",
86-
input.len()
50+
roundtrip_full::<FastPFor128, CppFastPFor128>(
51+
&input,
52+
Some(input.len().try_into().unwrap()),
8753
);
8854
}
8955
}
@@ -123,16 +89,9 @@ fn test_rust_and_cpp_compression_matches() {
12389
/// Rust `AnyLenCodec` (`CompositeCodec`) encoder → round-trip.
12490
#[test]
12591
fn test_rust_anylen_roundtrip() {
126-
let mut codec = FastPFor256::default();
127-
let mut compressed = Vec::new();
128-
let mut decoded = Vec::new();
12992
for n in test_input_sizes() {
13093
for input in get_test_cases(n) {
131-
compressed.truncate(0);
132-
decoded.truncate(0);
133-
codec.encode(&input, &mut compressed).unwrap();
134-
codec.decode(&compressed, &mut decoded, None).unwrap();
135-
assert_eq!(decoded, input, "Rust AnyLenCodec round-trip failed");
94+
roundtrip::<FastPFor256>(&input);
13695
}
13796
}
13897
}

0 commit comments

Comments
 (0)