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.
This commit is contained in:
Jan Petykiewicz 2026-11-14 14:37:35 -08:00
commit 3783320f82

91
tests/writing.rs Normal file
View file

@ -0,0 +1,91 @@
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());
}