pheon/tests/parser_errors.rs

155 lines
5.7 KiB
Rust
Raw Normal View History

mod common;
use arrow_array::ffi::{FFI_ArrowArray, FFI_ArrowSchema};
use pheon::{
basic::ErrType,
last_error_message,
library::{read_library, read_selected_library, scan_library},
read_bytes, read_cells_bytes,
record::RecordHeader,
records, scan_bytes,
};
use std::ffi::CStr;
fn fixture() -> (Vec<u8>, (u64, u64)) {
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, "töp".as_bytes());
common::record(&mut bytes, records::RTAG_SREF, &[]);
common::record(&mut bytes, records::RTAG_SNAME, "töp".as_bytes());
common::record(&mut bytes, records::RTAG_XY, &[0; 8]);
common::record(&mut bytes, records::RTAG_PROPATTR, &1_i16.to_be_bytes());
common::record(&mut bytes, records::RTAG_PROPVALUE, b"value\0");
common::record(&mut bytes, records::RTAG_ENDEL, &[]);
common::record(&mut bytes, records::RTAG_TEXT, &[]);
common::record(&mut bytes, records::RTAG_LAYER, &[0; 2]);
common::record(&mut bytes, records::RTAG_TEXTTYPE, &[0; 2]);
common::record(&mut bytes, records::RTAG_XY, &[0; 8]);
common::record(&mut bytes, records::RTAG_STRING, b"label\0");
common::record(&mut bytes, records::RTAG_ENDEL, &[]);
common::record(&mut bytes, records::RTAG_ENDSTR, &[]);
let end = bytes.len() as u64;
common::record(&mut bytes, records::RTAG_ENDLIB, &[]);
(bytes, (start, end))
}
fn payload_range(bytes: &[u8], tag: u16) -> std::ops::Range<usize> {
let mut offset = 0;
loop {
let (_, header) = RecordHeader::read(&bytes[offset..]).unwrap();
let start = offset + 4;
let end = start + usize::from(header.data_size);
if header.tag == tag {
return start..end;
}
offset = end;
}
}
fn check_ffi_error(
expected: &str,
call: impl FnOnce(&mut FFI_ArrowArray, &mut FFI_ArrowSchema) -> i32,
) {
let mut array = FFI_ArrowArray::empty();
let mut schema = FFI_ArrowSchema::empty();
assert_eq!(call(&mut array, &mut schema), -1);
let pointer = last_error_message();
assert!(!pointer.is_null());
let error = unsafe { CStr::from_ptr(pointer) }.to_str().unwrap();
assert!(error.contains(expected), "{error}");
assert!(
error.len() < 256,
"error should not dump the input: {error}"
);
assert!(array.is_released());
}
fn check_read_errors(bytes: &[u8], range: (u64, u64), offset: usize, message: &str, scan: bool) {
let ranges = [range];
let mut results = vec![read_library(bytes), read_selected_library(bytes, &ranges)];
if scan {
results.push(scan_library(bytes));
} else {
// Hierarchy scans deliberately skip text geometry and its string payloads.
assert!(scan_library(bytes).is_ok());
}
for result in results {
let (remaining, error) = result.unwrap_err();
assert_eq!(remaining.as_ptr(), bytes[offset..].as_ptr());
assert!(matches!(error, ErrType::Failed(reason) if reason.starts_with(message)));
}
let expected = format!("at byte {offset}: {message}");
check_ffi_error(&expected, |a, s| unsafe {
read_bytes(bytes.as_ptr(), bytes.len(), a, s)
});
let offsets = [range.0, range.1];
check_ffi_error(&expected, |a, s| unsafe {
read_cells_bytes(bytes.as_ptr(), bytes.len(), offsets.as_ptr(), 1, a, s)
});
if scan {
check_ffi_error(&expected, |a, s| unsafe {
scan_bytes(bytes.as_ptr(), bytes.len(), a, s)
});
}
}
#[test]
fn invalid_utf8_returns_located_parse_errors_in_each_reader() {
let (bytes, range) = fixture();
assert!(read_library(&bytes).is_ok());
assert!(read_selected_library(&bytes, &[range]).is_ok());
assert!(scan_library(&bytes).is_ok());
for tag in [
records::RTAG_LIBNAME,
records::RTAG_STRNAME,
records::RTAG_SNAME,
records::RTAG_STRING,
records::RTAG_PROPVALUE,
] {
let mut malformed = bytes.clone();
let payload = payload_range(&malformed, tag);
malformed[payload.start] = 0xff;
// UTF-8 is checked at the current parser cursor, after the record/header.
let offset = if tag == records::RTAG_LIBNAME {
payload_range(&malformed, records::RTAG_UNITS).end
} else {
payload.end
};
check_read_errors(
&malformed,
range,
offset,
"Invalid UTF-8 string:",
tag != records::RTAG_STRING,
);
}
}
#[test]
fn large_invalid_utf8_strings_do_not_dump_their_contents() {
let (mut bytes, range) = fixture();
let payload = payload_range(&bytes, records::RTAG_PROPVALUE);
let mut replacement = Vec::new();
let mut value = vec![b'a'; 60_000];
value[30_000] = 0xff;
common::record(&mut replacement, records::RTAG_PROPVALUE, &value);
let added = replacement.len() - (payload.end - payload.start + 4);
bytes.splice(payload.start - 4..payload.end, replacement);
let range = (range.0, range.1 + added as u64);
let offset = payload_range(&bytes, records::RTAG_PROPVALUE).end;
check_read_errors(&bytes, range, offset, "Invalid UTF-8 string:", true);
}
#[test]
fn overflowing_library_and_cell_years_return_the_same_error_in_each_reader() {
for tag in [records::RTAG_BGNLIB, records::RTAG_BGNSTR] {
for timestamp in [0, 1] {
let (mut bytes, range) = fixture();
let payload = payload_range(&bytes, tag);
let offset = payload.start + timestamp * 12;
bytes[offset..offset + 2].copy_from_slice(&i16::MAX.to_be_bytes());
check_read_errors(&bytes, range, offset, "Timestamp year", true);
}
}
}