Validate GDSII record sizes through one fallible path

Route every record read through size validation and report malformed payloads
as parse errors instead of panicking. Apply metadata size constraints through
the Record trait, hide Arrow reader internals, and remove unused wrappers and
scratch code.

Add coverage for direct, skipped, and payload reads, truncated buffers, and
FFI error offsets.
This commit is contained in:
Jan Petykiewicz 2026-11-16 20:44:48 -08:00
commit 54aa757678
2 changed files with 168 additions and 150 deletions

View file

@ -31,20 +31,20 @@ fn error_message() -> String {
}
#[test]
fn path_errors_preserve_outputs_and_convert_parser_panics() {
fn path_errors_preserve_outputs_and_clear_after_success() {
let mut array = FFI_ArrowArray::empty();
let mut schema = FFI_ArrowSchema::empty();
assert_eq!(unsafe { read_path(ptr::null(), &mut array, &mut schema) }, -1);
assert!(error_message().contains("path pointer was null"));
assert!(array.is_released());
// A mismatched timestamp size currently makes Record::read panic.
// A mismatched timestamp size returns a parse error with a byte offset.
let mut bytes = Vec::new();
common::record(&mut bytes, records::RTAG_HEADER, &600_i16.to_be_bytes());
common::record(&mut bytes, records::RTAG_BGNLIB, &[0; 12]);
let file = TestFile::new("invalid-timestamps", &bytes);
assert_eq!(unsafe { read_path(file.cpath().as_ptr(), &mut array, &mut schema) }, -1);
assert!(error_message().contains("Expected record size"));
assert!(error_message().contains("read failed at byte 10: Expected record size"));
assert!(array.is_released());
let mut bytes = common::library_header();

View file

@ -0,0 +1,99 @@
mod common;
use pheon::{
basic::ErrType,
record::{
ASCII, BitArray, DateTimePair, Empty, Int2, Int2Array, Int4, Int4Array, Real8, Real8Pair,
Record, RecordData,
},
records,
};
#[test]
fn fixed_record_sizes_are_checked_by_every_read_entry_point() {
let payload = [0; 4];
let mut bytes = Vec::new();
common::record(&mut bytes, records::RTAG_HEADER, &payload);
let mut prefixed = Vec::new();
common::record(&mut prefixed, records::RTAG_LIBNAME, b"skip");
prefixed.extend_from_slice(&bytes);
for result in [
records::HEADER::read(&bytes),
records::HEADER::skip_and_read(&prefixed),
records::HEADER::read_data(&payload, 4),
] {
let (remaining, reason) = result.unwrap_err();
assert_eq!(remaining, payload);
assert!(matches!(reason, ErrType::Failed(message)
if message == "Expected record size 2, got 4"));
}
// The underlying integer-array payload is aligned, but COLROW needs two values.
let payload = [0; 2];
let mut bytes = Vec::new();
common::record(&mut bytes, records::RTAG_COLROW, &payload);
assert!(records::COLROW::read(&bytes).is_err());
assert!(records::COLROW::skip_and_read(&bytes).is_err());
assert!(records::COLROW::read_data(&payload, 2).is_err());
}
#[test]
fn metadata_size_constraints_apply_to_every_read_entry_point() {
macro_rules! check {
($record:ident, $tag:ident) => {{
let payload = [b'x'; 44];
let mut bytes = Vec::new();
common::record(&mut bytes, records::$tag, &payload);
let mut prefixed = common::library_header();
prefixed.extend_from_slice(&bytes);
assert_eq!(records::$record::read(&bytes).unwrap().1, payload);
assert_eq!(
records::$record::skip_and_read(&prefixed).unwrap().1,
payload
);
assert_eq!(
records::$record::read_data(&payload, 44).unwrap().1,
payload
);
let payload = [b'x'; 46];
let mut bytes = Vec::new();
common::record(&mut bytes, records::$tag, &payload);
assert!(records::$record::read(&bytes).is_err());
assert!(records::$record::skip_and_read(&bytes).is_err());
assert!(records::$record::read_data(&payload, 46).is_err());
}};
}
check!(REFLIBS, RTAG_REFLIBS);
check!(FONTS, RTAG_FONTS);
check!(ATTRTABLE, RTAG_ATTRTABLE);
}
#[test]
fn malformed_payload_sizes_return_errors_without_panicking() {
let payload = [0; 32];
assert!(BitArray::read(&payload, 4).is_err());
assert!(Int2::read(&payload, 4).is_err());
assert!(Int4::read(&payload, 2).is_err());
assert!(Real8::read(&payload, 4).is_err());
assert!(Real8Pair::read(&payload, 8).is_err());
assert!(DateTimePair::read(&payload, 12).is_err());
assert!(Empty::read(&payload, 2).is_err());
assert!(Int2Array::read(&payload, 3).is_err());
assert!(Int4Array::read(&payload, 6).is_err());
let mut bytes = Vec::new();
common::record(&mut bytes, records::RTAG_XY, &payload[..6]);
assert!(records::XY::read(&bytes).is_err());
assert!(records::XY::skip_and_read(&bytes).is_err());
assert!(records::XY::read_data(&payload, 6).is_err());
// Valid sizes still reject a truncated buffer; an empty string remains valid.
assert!(Int4::read(&payload[..2], 4).is_err());
assert!(Real8Pair::read(&payload[..8], 16).is_err());
assert!(DateTimePair::read(&payload[..12], 24).is_err());
assert!(Int4Array::read(&payload[..4], 8).is_err());
assert_eq!(ASCII::read(&[], 0).unwrap(), (&[][..], Vec::<u8>::new()));
}