pheon/tests/ffi_errors.rs
Jan Petykiewicz 54aa757678 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.
2026-11-16 20:44:48 -08:00

157 lines
5.4 KiB
Rust

mod common;
use arrow_array::ffi::{FFI_ArrowArray, FFI_ArrowSchema};
use pheon::{last_error_message, read_path, read_cells_bytes, scan_bytes, records};
use std::{ffi::{CStr, CString}, fs, path::PathBuf, ptr};
struct TestFile(PathBuf);
impl TestFile {
fn new(name: &str, contents: &[u8]) -> Self {
let path = std::env::temp_dir().join(format!("pheon-{name}-{}.gds", std::process::id()));
fs::write(&path, contents).unwrap();
Self(path)
}
fn cpath(&self) -> CString {
CString::new(self.0.to_str().unwrap()).unwrap()
}
}
impl Drop for TestFile {
fn drop(&mut self) {
let _ = fs::remove_file(&self.0);
}
}
fn error_message() -> String {
let message = last_error_message();
assert!(!message.is_null());
unsafe { CStr::from_ptr(message) }.to_str().unwrap().to_owned()
}
#[test]
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 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("read failed at byte 10: Expected record size"));
assert!(array.is_released());
let mut bytes = common::library_header();
common::record(&mut bytes, records::RTAG_ENDLIB, &[]);
let file = TestFile::new("valid-empty", &bytes);
assert_eq!(unsafe { read_path(file.cpath().as_ptr(), &mut array, &mut schema) }, 0);
assert!(!array.is_released());
assert!(last_error_message().is_null());
}
#[test]
fn other_threads_do_not_clear_or_free_error_messages() {
let mut array = FFI_ArrowArray::empty();
let mut schema = FFI_ArrowSchema::empty();
assert_eq!(unsafe { read_path(ptr::null(), &mut array, &mut schema) }, -1);
let pointer = last_error_message();
let message = error_message();
std::thread::spawn(|| {
assert!(last_error_message().is_null());
let mut bytes = common::library_header();
common::record(&mut bytes, records::RTAG_ENDLIB, &[]);
let file = TestFile::new("thread-empty", &bytes);
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_eq!(unsafe { read_path(file.cpath().as_ptr(), &mut array, &mut schema) }, 0);
assert!(last_error_message().is_null());
}).join().unwrap();
assert_eq!(last_error_message(), pointer);
assert_eq!(unsafe { CStr::from_ptr(pointer) }.to_str().unwrap(), message);
}
#[test]
fn null_arrow_outputs_return_an_error() {
assert_eq!(unsafe { read_path(ptr::null(), ptr::null_mut(), ptr::null_mut()) }, -1);
assert!(error_message().contains("Arrow output pointer was null"));
}
#[test]
fn large_malformed_inputs_report_offsets_without_dumping_contents() {
let mut bytes = vec![0; 1024 * 1024 + 4];
bytes[..4].copy_from_slice(&[0, 4, 0xff, 0xff]);
let mut array = FFI_ArrowArray::empty();
let mut schema = FFI_ArrowSchema::empty();
let file = TestFile::new("large-malformed", &bytes);
assert_eq!(
unsafe { scan_bytes(bytes.as_ptr(), bytes.len(), &mut array, &mut schema) },
-1
);
let scan_message = error_message();
assert_eq!(
unsafe { read_path(file.cpath().as_ptr(), &mut array, &mut schema) },
-1
);
let read_message = error_message();
assert_eq!(
unsafe {
read_cells_bytes(
bytes.as_ptr(),
bytes.len(),
ptr::null(),
0,
&mut array,
&mut schema,
)
},
-1
);
let selected_message = error_message();
for message in [scan_message, read_message, selected_message] {
assert!(message.contains("at byte 4"), "{message}");
assert!(message.contains("Unexpected record"), "{message}");
assert!(message.len() < 256);
}
assert!(array.is_released());
}
#[test]
fn selected_cell_errors_use_file_offsets_for_bounded_ranges() {
let mut bytes = common::library_header();
let start = bytes.len() as u64;
common::record(&mut bytes, records::RTAG_BGNSTR, &[0; 24]);
common::record(&mut bytes, records::RTAG_STRNAME, b"top\0");
common::record(&mut bytes, records::RTAG_ENDSTR, &[]);
let cell_end = bytes.len();
common::record(&mut bytes, records::RTAG_ENDLIB, &[]);
let range_end = bytes.len() as u64;
bytes.resize(bytes.len() + 1024, 0);
let ranges = [start, range_end];
let mut array = FFI_ArrowArray::empty();
let mut schema = FFI_ArrowSchema::empty();
assert_eq!(
unsafe {
read_cells_bytes(
bytes.as_ptr(),
bytes.len(),
ranges.as_ptr(),
1,
&mut array,
&mut schema,
)
},
-1
);
assert!(error_message().contains(&format!(
"at byte {cell_end}: Cell byte range extends past ENDSTR"
)));
}