pheon/tests/writing.rs
Jan Petykiewicz 3783320f82 fix(writer): serialize complete records with correctly sized buffers
Include record headers in wire lengths, allocate initialized array and padded string buffers, and handle empty strings. Write all bytes to short writers and reject oversized records before writing.
2026-11-14 14:37:35 -08:00

91 lines
2.8 KiB
Rust

use arrow::array::Array;
use klamath_rs_ext::{
library::{FileHeader, read_library},
record::{Record, RecordHeader},
records,
};
use std::io::{self, Write};
#[test]
fn record_headers_include_their_own_size() {
let mut bytes = Vec::new();
assert_eq!(records::HEADER::write(&mut bytes, &600).unwrap(), 6);
assert_eq!(bytes, [0, 6, 0, 2, 2, 88]);
let (remaining, value) = records::HEADER::read(&bytes).unwrap();
assert!(remaining.is_empty());
assert_eq!(value, 600);
let maximum = RecordHeader {
data_size: u16::MAX - 4,
tag: 0x1003,
};
assert_eq!(maximum.pack_into(), [0xff, 0xff, 0x10, 0x03]);
}
#[test]
fn integer_array_records_round_trip() {
let mut bytes = Vec::new();
records::COLROW::write(&mut bytes, &[2, 3]).unwrap();
let (remaining, values) = records::COLROW::read(&bytes).unwrap();
assert!(remaining.is_empty());
assert_eq!(values.collect::<Vec<_>>(), [2, 3]);
let mut bytes = Vec::new();
let values = [i32::MIN, -1, 0, i32::MAX];
records::XY::write(&mut bytes, &values).unwrap();
let (remaining, parsed) = records::XY::read(&bytes).unwrap();
assert!(remaining.is_empty());
assert_eq!(parsed.collect::<Vec<_>>(), values);
}
#[test]
fn string_records_pad_only_when_needed_and_support_empty_strings() {
for value in [b"".as_slice(), b"odd", b"even"] {
let mut bytes = Vec::new();
let expected_size = 4 + value.len() + value.len() % 2;
assert_eq!(
records::LIBNAME::write(&mut bytes, value).unwrap(),
expected_size
);
assert_eq!(bytes.len(), expected_size);
let (remaining, parsed) = records::LIBNAME::read(&bytes).unwrap();
assert!(remaining.is_empty());
assert_eq!(parsed, value);
if value.len() % 2 == 1 {
assert_eq!(bytes.last(), Some(&0));
}
}
}
struct ShortWriter(Vec<u8>);
impl Write for ShortWriter {
fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
let size = bytes.len().min(1);
self.0.extend_from_slice(&bytes[..size]);
Ok(size)
}
fn flush(&mut self) -> io::Result<()> {
Ok(())
}
}
#[test]
fn library_header_round_trips_through_a_short_writer() {
let header = FileHeader::new(b"odd", 1e-9, 0.001);
let mut writer = ShortWriter(Vec::new());
let mut written = header.write(&mut writer).unwrap();
written += records::ENDLIB::write(&mut writer, &()).unwrap();
assert_eq!(written, writer.0.len());
let (remaining, library) = read_library(&writer.0).unwrap();
assert!(remaining.is_empty());
assert_eq!(library.len(), 1);
}
#[test]
fn oversized_records_fail_before_writing() {
let mut bytes = Vec::new();
let error = records::XY::write(&mut bytes, &vec![0; 16383]).unwrap_err();
assert_eq!(error.kind(), io::ErrorKind::InvalidInput);
assert!(bytes.is_empty());
}