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.
91 lines
2.8 KiB
Rust
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());
|
|
}
|