Introduce Pheon GDSII parsing and layout review tools
Implement native GDSII reading and writing with Arrow interchange, hierarchy scans and selective cell loading. Validate numeric packing and array pitches, and preserve normalized REAL8 encodings exactly within the supported range. Add standalone dump, structural diff, hierarchy, layer-name annotation and Git diff commands. Provide scoped text and JSON reports, deterministic comparison, and record-preserving metadata edits. Package the shared library and optional Python Arrow readers as pheon using CFFI ABI mode and Python-independent platform wheels. Include locked source builds, native API checks, cross-platform artifact workflows, documentation and regression coverage. Require Rust 1.88 or newer and Python 3.11 or newer. Validation: 87 native tests, 14 binding tests on Python 3.11/3.13/3.14, and 71 installed companion integration tests pass. Full, scanned and selected Arrow layouts match the previous schemas.
This commit is contained in:
parent
e0a634f476
commit
b3346b40a4
21 changed files with 12956 additions and 1 deletions
20
tests/common/mod.rs
Normal file
20
tests/common/mod.rs
Normal file
|
|
@ -0,0 +1,20 @@
|
|||
use pheon::{basic::encode_real8, records};
|
||||
|
||||
pub fn record(out: &mut Vec<u8>, tag: u16, data: &[u8]) {
|
||||
out.extend_from_slice(&u16::try_from(data.len() + 4).unwrap().to_be_bytes());
|
||||
out.extend_from_slice(&tag.to_be_bytes());
|
||||
out.extend_from_slice(data);
|
||||
}
|
||||
|
||||
pub fn library_header() -> Vec<u8> {
|
||||
let mut bytes = Vec::new();
|
||||
record(&mut bytes, records::RTAG_HEADER, &600_i16.to_be_bytes());
|
||||
record(&mut bytes, records::RTAG_BGNLIB, &[0; 24]);
|
||||
record(&mut bytes, records::RTAG_LIBNAME, b"test");
|
||||
let units: Vec<u8> = [0.001, 1e-9]
|
||||
.into_iter()
|
||||
.flat_map(|v| encode_real8(v).unwrap().to_be_bytes())
|
||||
.collect();
|
||||
record(&mut bytes, records::RTAG_UNITS, &units);
|
||||
bytes
|
||||
}
|
||||
157
tests/ffi_errors.rs
Normal file
157
tests/ffi_errors.rs
Normal file
|
|
@ -0,0 +1,157 @@
|
|||
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_convert_parser_panics() {
|
||||
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.
|
||||
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!(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"
|
||||
)));
|
||||
}
|
||||
78
tests/golden/report-equal.json
Normal file
78
tests/golden/report-equal.json
Normal file
|
|
@ -0,0 +1,78 @@
|
|||
{
|
||||
"cell_changes": [],
|
||||
"comparison_profile": "klamath-object-v2",
|
||||
"coordinates": {
|
||||
"bounds": "coordinate_envelope",
|
||||
"frame": "cell_local",
|
||||
"unit": "database_unit"
|
||||
},
|
||||
"diagnostics": [],
|
||||
"exit_code": 0,
|
||||
"hierarchy": null,
|
||||
"inputs": {
|
||||
"new": {
|
||||
"path": "after.gds",
|
||||
"path_encoded_hex": null,
|
||||
"present": true,
|
||||
"units": {
|
||||
"encoding": "real8",
|
||||
"name": "UNITS",
|
||||
"payload_hex": "0x3e4189374bc6a7f03944b82fa09b5a54",
|
||||
"tag": 773,
|
||||
"value": [
|
||||
0.001,
|
||||
1e-9
|
||||
]
|
||||
}
|
||||
},
|
||||
"old": {
|
||||
"path": "before.gds",
|
||||
"path_encoded_hex": null,
|
||||
"present": true,
|
||||
"units": {
|
||||
"encoding": "real8",
|
||||
"name": "UNITS",
|
||||
"payload_hex": "0x3e4189374bc6a7f03944b82fa09b5a54",
|
||||
"tag": 773,
|
||||
"value": [
|
||||
0.001,
|
||||
1e-9
|
||||
]
|
||||
}
|
||||
}
|
||||
},
|
||||
"kind": "diff",
|
||||
"layer_legend": [],
|
||||
"layer_name_changes": [],
|
||||
"library_changes": [],
|
||||
"producer": {
|
||||
"name": "pheon",
|
||||
"version": "test"
|
||||
},
|
||||
"report_selection": {
|
||||
"cell": null,
|
||||
"emitted_objects": "0",
|
||||
"filtered_cells": "0",
|
||||
"filtered_objects": "0",
|
||||
"layer": null,
|
||||
"limited_objects": "0",
|
||||
"max_objects": null,
|
||||
"truncated": false
|
||||
},
|
||||
"result": "equal",
|
||||
"schema_version": 1,
|
||||
"scope": {
|
||||
"cell": null,
|
||||
"layer": null,
|
||||
"top": null
|
||||
},
|
||||
"status": "complete",
|
||||
"summary": {
|
||||
"added_objects": "0",
|
||||
"changed_cells": "0",
|
||||
"counts": "exact",
|
||||
"layer_name_changes": "0",
|
||||
"library_field_changes": "0",
|
||||
"removed_objects": "0"
|
||||
}
|
||||
}
|
||||
64
tests/golden/report-failed.json
Normal file
64
tests/golden/report-failed.json
Normal file
|
|
@ -0,0 +1,64 @@
|
|||
{
|
||||
"cell_changes": [],
|
||||
"comparison_profile": "klamath-object-v2",
|
||||
"coordinates": {
|
||||
"bounds": "coordinate_envelope",
|
||||
"frame": "cell_local",
|
||||
"unit": "database_unit"
|
||||
},
|
||||
"diagnostics": [
|
||||
{
|
||||
"byte_offset": null,
|
||||
"cell": null,
|
||||
"code": "invalid_input",
|
||||
"layer": null,
|
||||
"message": "truncated record",
|
||||
"severity": "error",
|
||||
"side": "new",
|
||||
"target": null
|
||||
}
|
||||
],
|
||||
"exit_code": 2,
|
||||
"hierarchy": null,
|
||||
"inputs": {
|
||||
"new": {
|
||||
"path": "after.gds",
|
||||
"path_encoded_hex": null,
|
||||
"present": null,
|
||||
"units": null
|
||||
},
|
||||
"old": {
|
||||
"path": "before.gds",
|
||||
"path_encoded_hex": null,
|
||||
"present": null,
|
||||
"units": null
|
||||
}
|
||||
},
|
||||
"kind": "diff",
|
||||
"layer_legend": [],
|
||||
"layer_name_changes": [],
|
||||
"library_changes": [],
|
||||
"producer": {
|
||||
"name": "pheon",
|
||||
"version": "test"
|
||||
},
|
||||
"report_selection": {
|
||||
"cell": null,
|
||||
"emitted_objects": "0",
|
||||
"filtered_cells": "0",
|
||||
"filtered_objects": "0",
|
||||
"layer": null,
|
||||
"limited_objects": "0",
|
||||
"max_objects": null,
|
||||
"truncated": false
|
||||
},
|
||||
"result": "unknown",
|
||||
"schema_version": 1,
|
||||
"scope": {
|
||||
"cell": null,
|
||||
"layer": null,
|
||||
"top": null
|
||||
},
|
||||
"status": "failed",
|
||||
"summary": null
|
||||
}
|
||||
360
tests/golden/report-geometry.json
Normal file
360
tests/golden/report-geometry.json
Normal file
|
|
@ -0,0 +1,360 @@
|
|||
{
|
||||
"cell_changes": [
|
||||
{
|
||||
"added": [
|
||||
{
|
||||
"bounds": [
|
||||
0,
|
||||
0,
|
||||
10,
|
||||
10
|
||||
],
|
||||
"counts": null,
|
||||
"fields": [
|
||||
{
|
||||
"encoding": "uint16",
|
||||
"name": "layer",
|
||||
"payload_hex": "0x0001",
|
||||
"tag": 3330,
|
||||
"value": [
|
||||
1
|
||||
]
|
||||
},
|
||||
{
|
||||
"encoding": "uint16",
|
||||
"name": "datatype",
|
||||
"payload_hex": "0x0000",
|
||||
"tag": 3586,
|
||||
"value": [
|
||||
0
|
||||
]
|
||||
},
|
||||
{
|
||||
"encoding": "xy",
|
||||
"name": "xy",
|
||||
"payload_hex": "0x0000000000000000000000000000000a0000000a000000000000000000000000",
|
||||
"tag": 4099,
|
||||
"value": [
|
||||
[
|
||||
0,
|
||||
0
|
||||
],
|
||||
[
|
||||
0,
|
||||
10
|
||||
],
|
||||
[
|
||||
10,
|
||||
0
|
||||
],
|
||||
[
|
||||
0,
|
||||
0
|
||||
]
|
||||
]
|
||||
}
|
||||
],
|
||||
"id": "c0:new:0",
|
||||
"kind": "BOUNDARY",
|
||||
"layer": {
|
||||
"number": 1,
|
||||
"purpose": 0
|
||||
},
|
||||
"origin": null,
|
||||
"properties": [],
|
||||
"source": {
|
||||
"byte_offset": "382",
|
||||
"end_offset": "438",
|
||||
"side": "new"
|
||||
},
|
||||
"tag": 2048,
|
||||
"target": null,
|
||||
"width": null
|
||||
}
|
||||
],
|
||||
"after": {
|
||||
"attributes": [],
|
||||
"byte_offset": "346"
|
||||
},
|
||||
"attributes_changed": false,
|
||||
"before": {
|
||||
"attributes": [],
|
||||
"byte_offset": "346"
|
||||
},
|
||||
"name": "leaf",
|
||||
"removed": [
|
||||
{
|
||||
"bounds": [
|
||||
0,
|
||||
0,
|
||||
10,
|
||||
10
|
||||
],
|
||||
"counts": null,
|
||||
"fields": [
|
||||
{
|
||||
"encoding": "uint16",
|
||||
"name": "layer",
|
||||
"payload_hex": "0x0001",
|
||||
"tag": 3330,
|
||||
"value": [
|
||||
1
|
||||
]
|
||||
},
|
||||
{
|
||||
"encoding": "uint16",
|
||||
"name": "datatype",
|
||||
"payload_hex": "0x0000",
|
||||
"tag": 3586,
|
||||
"value": [
|
||||
0
|
||||
]
|
||||
},
|
||||
{
|
||||
"encoding": "xy",
|
||||
"name": "xy",
|
||||
"payload_hex": "0x0000000000000000000000000000000a0000000a0000000a0000000a000000000000000000000000",
|
||||
"tag": 4099,
|
||||
"value": [
|
||||
[
|
||||
0,
|
||||
0
|
||||
],
|
||||
[
|
||||
0,
|
||||
10
|
||||
],
|
||||
[
|
||||
10,
|
||||
10
|
||||
],
|
||||
[
|
||||
10,
|
||||
0
|
||||
],
|
||||
[
|
||||
0,
|
||||
0
|
||||
]
|
||||
]
|
||||
}
|
||||
],
|
||||
"id": "c0:old:0",
|
||||
"kind": "BOUNDARY",
|
||||
"layer": {
|
||||
"number": 1,
|
||||
"purpose": 0
|
||||
},
|
||||
"origin": null,
|
||||
"properties": [],
|
||||
"source": {
|
||||
"byte_offset": "382",
|
||||
"end_offset": "446",
|
||||
"side": "old"
|
||||
},
|
||||
"tag": 2048,
|
||||
"target": null,
|
||||
"width": null
|
||||
}
|
||||
],
|
||||
"replacements": [
|
||||
{
|
||||
"added": "c0:new:0",
|
||||
"explanation": "BOUNDARY modified; coordinate bounds unchanged",
|
||||
"field_changes": [
|
||||
{
|
||||
"after": {
|
||||
"encoding": "xy",
|
||||
"name": "xy",
|
||||
"payload_hex": "0x0000000000000000000000000000000a0000000a000000000000000000000000",
|
||||
"tag": 4099,
|
||||
"value": [
|
||||
[
|
||||
0,
|
||||
0
|
||||
],
|
||||
[
|
||||
0,
|
||||
10
|
||||
],
|
||||
[
|
||||
10,
|
||||
0
|
||||
],
|
||||
[
|
||||
0,
|
||||
0
|
||||
]
|
||||
]
|
||||
},
|
||||
"before": {
|
||||
"encoding": "xy",
|
||||
"name": "xy",
|
||||
"payload_hex": "0x0000000000000000000000000000000a0000000a0000000a0000000a000000000000000000000000",
|
||||
"tag": 4099,
|
||||
"value": [
|
||||
[
|
||||
0,
|
||||
0
|
||||
],
|
||||
[
|
||||
0,
|
||||
10
|
||||
],
|
||||
[
|
||||
10,
|
||||
10
|
||||
],
|
||||
[
|
||||
10,
|
||||
0
|
||||
],
|
||||
[
|
||||
0,
|
||||
0
|
||||
]
|
||||
]
|
||||
},
|
||||
"tag": 4099
|
||||
}
|
||||
],
|
||||
"match_rule": "unique_kind_layer_bounds",
|
||||
"properties_changed": false,
|
||||
"removed": "c0:old:0"
|
||||
}
|
||||
]
|
||||
}
|
||||
],
|
||||
"comparison_profile": "klamath-object-v2",
|
||||
"coordinates": {
|
||||
"bounds": "coordinate_envelope",
|
||||
"frame": "cell_local",
|
||||
"unit": "database_unit"
|
||||
},
|
||||
"diagnostics": [],
|
||||
"exit_code": 1,
|
||||
"hierarchy": {
|
||||
"edges": [
|
||||
{
|
||||
"after_count": "1",
|
||||
"before_count": "1",
|
||||
"parent": "CHIP",
|
||||
"reference_changed": false,
|
||||
"target": "left"
|
||||
},
|
||||
{
|
||||
"after_count": "1",
|
||||
"before_count": "1",
|
||||
"parent": "CHIP",
|
||||
"reference_changed": false,
|
||||
"target": "right"
|
||||
},
|
||||
{
|
||||
"after_count": "2",
|
||||
"before_count": "2",
|
||||
"parent": "left",
|
||||
"reference_changed": false,
|
||||
"target": "leaf"
|
||||
},
|
||||
{
|
||||
"after_count": "3",
|
||||
"before_count": "3",
|
||||
"parent": "right",
|
||||
"reference_changed": false,
|
||||
"target": "leaf"
|
||||
}
|
||||
],
|
||||
"nodes": [
|
||||
{
|
||||
"after": "included",
|
||||
"before": "included",
|
||||
"cell": "CHIP",
|
||||
"change": "affected"
|
||||
},
|
||||
{
|
||||
"after": "included",
|
||||
"before": "included",
|
||||
"cell": "leaf",
|
||||
"change": "direct"
|
||||
},
|
||||
{
|
||||
"after": "included",
|
||||
"before": "included",
|
||||
"cell": "left",
|
||||
"change": "affected"
|
||||
},
|
||||
{
|
||||
"after": "included",
|
||||
"before": "included",
|
||||
"cell": "right",
|
||||
"change": "affected"
|
||||
}
|
||||
]
|
||||
},
|
||||
"inputs": {
|
||||
"new": {
|
||||
"path": "after.gds",
|
||||
"path_encoded_hex": null,
|
||||
"present": true,
|
||||
"units": {
|
||||
"encoding": "real8",
|
||||
"name": "UNITS",
|
||||
"payload_hex": "0x3e4189374bc6a7f03944b82fa09b5a54",
|
||||
"tag": 773,
|
||||
"value": [
|
||||
0.001,
|
||||
1e-9
|
||||
]
|
||||
}
|
||||
},
|
||||
"old": {
|
||||
"path": "before.gds",
|
||||
"path_encoded_hex": null,
|
||||
"present": true,
|
||||
"units": {
|
||||
"encoding": "real8",
|
||||
"name": "UNITS",
|
||||
"payload_hex": "0x3e4189374bc6a7f03944b82fa09b5a54",
|
||||
"tag": 773,
|
||||
"value": [
|
||||
0.001,
|
||||
1e-9
|
||||
]
|
||||
}
|
||||
}
|
||||
},
|
||||
"kind": "diff",
|
||||
"layer_legend": [],
|
||||
"layer_name_changes": [],
|
||||
"library_changes": [],
|
||||
"producer": {
|
||||
"name": "pheon",
|
||||
"version": "test"
|
||||
},
|
||||
"report_selection": {
|
||||
"cell": null,
|
||||
"emitted_objects": "2",
|
||||
"filtered_cells": "0",
|
||||
"filtered_objects": "0",
|
||||
"layer": null,
|
||||
"limited_objects": "0",
|
||||
"max_objects": null,
|
||||
"truncated": false
|
||||
},
|
||||
"result": "different",
|
||||
"schema_version": 1,
|
||||
"scope": {
|
||||
"cell": null,
|
||||
"layer": null,
|
||||
"top": null
|
||||
},
|
||||
"status": "complete",
|
||||
"summary": {
|
||||
"added_objects": "1",
|
||||
"changed_cells": "1",
|
||||
"counts": "exact",
|
||||
"layer_name_changes": "0",
|
||||
"library_field_changes": "0",
|
||||
"removed_objects": "1"
|
||||
}
|
||||
}
|
||||
105
tests/golden/report-incomplete.json
Normal file
105
tests/golden/report-incomplete.json
Normal file
|
|
@ -0,0 +1,105 @@
|
|||
{
|
||||
"cell_changes": [],
|
||||
"comparison_profile": "klamath-object-v2",
|
||||
"coordinates": {
|
||||
"bounds": "coordinate_envelope",
|
||||
"frame": "cell_local",
|
||||
"unit": "database_unit"
|
||||
},
|
||||
"diagnostics": [
|
||||
{
|
||||
"byte_offset": "158",
|
||||
"cell": "CHIP",
|
||||
"code": "unsupported_record",
|
||||
"layer": {
|
||||
"number": 1,
|
||||
"purpose": 0
|
||||
},
|
||||
"message": "cell \"CHIP\": at byte 158: unsupported record 0x7f02 in BOUNDARY",
|
||||
"severity": "error",
|
||||
"side": "old",
|
||||
"target": null
|
||||
},
|
||||
{
|
||||
"byte_offset": "158",
|
||||
"cell": "CHIP",
|
||||
"code": "unsupported_record",
|
||||
"layer": {
|
||||
"number": 1,
|
||||
"purpose": 0
|
||||
},
|
||||
"message": "cell \"CHIP\": at byte 158: unsupported record 0x7f02 in BOUNDARY",
|
||||
"severity": "error",
|
||||
"side": "new",
|
||||
"target": null
|
||||
}
|
||||
],
|
||||
"exit_code": 2,
|
||||
"hierarchy": null,
|
||||
"inputs": {
|
||||
"new": {
|
||||
"path": "after.gds",
|
||||
"path_encoded_hex": null,
|
||||
"present": true,
|
||||
"units": {
|
||||
"encoding": "real8",
|
||||
"name": "UNITS",
|
||||
"payload_hex": "0x3e4189374bc6a7f03944b82fa09b5a54",
|
||||
"tag": 773,
|
||||
"value": [
|
||||
0.001,
|
||||
1e-9
|
||||
]
|
||||
}
|
||||
},
|
||||
"old": {
|
||||
"path": "before.gds",
|
||||
"path_encoded_hex": null,
|
||||
"present": true,
|
||||
"units": {
|
||||
"encoding": "real8",
|
||||
"name": "UNITS",
|
||||
"payload_hex": "0x3e4189374bc6a7f03944b82fa09b5a54",
|
||||
"tag": 773,
|
||||
"value": [
|
||||
0.001,
|
||||
1e-9
|
||||
]
|
||||
}
|
||||
}
|
||||
},
|
||||
"kind": "diff",
|
||||
"layer_legend": [],
|
||||
"layer_name_changes": [],
|
||||
"library_changes": [],
|
||||
"producer": {
|
||||
"name": "pheon",
|
||||
"version": "test"
|
||||
},
|
||||
"report_selection": {
|
||||
"cell": null,
|
||||
"emitted_objects": "0",
|
||||
"filtered_cells": "0",
|
||||
"filtered_objects": "0",
|
||||
"layer": null,
|
||||
"limited_objects": "0",
|
||||
"max_objects": null,
|
||||
"truncated": false
|
||||
},
|
||||
"result": "unknown",
|
||||
"schema_version": 1,
|
||||
"scope": {
|
||||
"cell": null,
|
||||
"layer": null,
|
||||
"top": null
|
||||
},
|
||||
"status": "incomplete",
|
||||
"summary": {
|
||||
"added_objects": "0",
|
||||
"changed_cells": "0",
|
||||
"counts": "observed",
|
||||
"layer_name_changes": "0",
|
||||
"library_field_changes": "0",
|
||||
"removed_objects": "0"
|
||||
}
|
||||
}
|
||||
87
tests/golden/report-metadata.json
Normal file
87
tests/golden/report-metadata.json
Normal file
|
|
@ -0,0 +1,87 @@
|
|||
{
|
||||
"cell_changes": [],
|
||||
"comparison_profile": "klamath-object-v2",
|
||||
"coordinates": {
|
||||
"bounds": "coordinate_envelope",
|
||||
"frame": "cell_local",
|
||||
"unit": "database_unit"
|
||||
},
|
||||
"diagnostics": [],
|
||||
"exit_code": 1,
|
||||
"hierarchy": null,
|
||||
"inputs": {
|
||||
"new": {
|
||||
"path": "after.gds",
|
||||
"path_encoded_hex": null,
|
||||
"present": true,
|
||||
"units": {
|
||||
"encoding": "real8",
|
||||
"name": "UNITS",
|
||||
"payload_hex": "0x3e4189374bc6a7f03944b82fa09b5a54",
|
||||
"tag": 773,
|
||||
"value": [
|
||||
0.001,
|
||||
1e-9
|
||||
]
|
||||
}
|
||||
},
|
||||
"old": {
|
||||
"path": "before.gds",
|
||||
"path_encoded_hex": null,
|
||||
"present": true,
|
||||
"units": {
|
||||
"encoding": "real8",
|
||||
"name": "UNITS",
|
||||
"payload_hex": "0x3e4189374bc6a7f03944b82fa09b5a54",
|
||||
"tag": 773,
|
||||
"value": [
|
||||
0.001,
|
||||
1e-9
|
||||
]
|
||||
}
|
||||
}
|
||||
},
|
||||
"kind": "diff",
|
||||
"layer_legend": [],
|
||||
"layer_name_changes": [
|
||||
{
|
||||
"after": "CORE:WG",
|
||||
"before": "WG",
|
||||
"layer": {
|
||||
"number": 1,
|
||||
"purpose": 0
|
||||
}
|
||||
}
|
||||
],
|
||||
"library_changes": [],
|
||||
"producer": {
|
||||
"name": "pheon",
|
||||
"version": "test"
|
||||
},
|
||||
"report_selection": {
|
||||
"cell": null,
|
||||
"emitted_objects": "0",
|
||||
"filtered_cells": "0",
|
||||
"filtered_objects": "0",
|
||||
"layer": null,
|
||||
"limited_objects": "0",
|
||||
"max_objects": null,
|
||||
"truncated": false
|
||||
},
|
||||
"result": "different",
|
||||
"schema_version": 1,
|
||||
"scope": {
|
||||
"cell": null,
|
||||
"layer": null,
|
||||
"top": null
|
||||
},
|
||||
"status": "complete",
|
||||
"summary": {
|
||||
"added_objects": "0",
|
||||
"changed_cells": "0",
|
||||
"counts": "exact",
|
||||
"layer_name_changes": "1",
|
||||
"library_field_changes": "0",
|
||||
"removed_objects": "0"
|
||||
}
|
||||
}
|
||||
9
tests/golden/review-canonical.txt
Normal file
9
tests/golden/review-canonical.txt
Normal file
|
|
@ -0,0 +1,9 @@
|
|||
profile klamath-object-v2
|
||||
scope top=all cell=all layer=all
|
||||
coordinates: integer database units; bounds: coordinate envelopes
|
||||
HEADER=[600]
|
||||
LIBNAME="test"
|
||||
UNITS=[0.001, 1e-9] raw=0x3e4189374bc6a7f03944b82fa09b5a54
|
||||
layer 1/0 name="WG"
|
||||
cell "CHIP"
|
||||
BOUNDARY layer=1 datatype=0 xy=[0, 0, 0, 10, 10, 10, 10, 0, 0, 0]
|
||||
7
tests/golden/review-diff.txt
Normal file
7
tests/golden/review-diff.txt
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
profile klamath-object-v2
|
||||
scope top=all cell=all layer=all
|
||||
cell "CHIP" old@Some(62) new@Some(62)
|
||||
~ BOUNDARY modified; coordinate bounds unchanged
|
||||
- @98 bbox=Some([0, 0, 10, 10]) BOUNDARY layer=1 datatype=0 xy=[0, 0, 0, 10, 10, 10, 10, 0, 0, 0]
|
||||
+ @98 bbox=Some([0, 0, 10, 10]) BOUNDARY layer=1 datatype=0 xy=[0, 0, 0, 10, 10, 0, 0, 0]
|
||||
1 changed cells; 2 of 2 object changes shown; 0 layer-name changes
|
||||
10
tests/golden/review-hierarchy.mmd
Normal file
10
tests/golden/review-hierarchy.mmd
Normal file
|
|
@ -0,0 +1,10 @@
|
|||
flowchart TD
|
||||
%% scope top=all cell=all layer=all
|
||||
n0["CHIP [affected]"]
|
||||
n1["leaf [cell changed]"]
|
||||
n2["left [affected]"]
|
||||
n3["right [affected]"]
|
||||
n0 -->|"x1"| n2
|
||||
n0 -->|"x1"| n3
|
||||
n2 -->|"x2"| n1
|
||||
n3 -->|"x3"| n1
|
||||
6
tests/golden/review-hierarchy.txt
Normal file
6
tests/golden/review-hierarchy.txt
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
scope top=all cell=all layer=all
|
||||
"CHIP" x1 [affected]
|
||||
"left" x1 [affected]
|
||||
"leaf" x2 [cell changed]
|
||||
"right" x1 [affected]
|
||||
"leaf" x3 [cell changed] [shown above]
|
||||
103
tests/numeric_packing.rs
Normal file
103
tests/numeric_packing.rs
Normal file
|
|
@ -0,0 +1,103 @@
|
|||
use pheon::*;
|
||||
use std::{mem::size_of, slice};
|
||||
|
||||
// Read the packed prefix of each source slot, as the Python wrapper does.
|
||||
fn packed_bytes<T>(values: &[T], width: usize) -> Vec<u8> {
|
||||
let bytes = unsafe { slice::from_raw_parts(values.as_ptr().cast::<u8>(), size_of_val(values)) };
|
||||
bytes
|
||||
.chunks_exact(size_of::<T>())
|
||||
.flat_map(|slot| slot[..width].iter().copied())
|
||||
.collect()
|
||||
}
|
||||
|
||||
macro_rules! check_int2 {
|
||||
($ty:ty, $function:ident) => {{
|
||||
let mut values = [0 as $ty, 1 as $ty, 256 as $ty, 32767 as $ty];
|
||||
assert_eq!(
|
||||
unsafe { $function(values.as_mut_ptr(), values.len()) },
|
||||
0 as $ty
|
||||
);
|
||||
assert_eq!(packed_bytes(&values, 2), [0, 0, 0, 1, 1, 0, 0x7f, 0xff]);
|
||||
}};
|
||||
}
|
||||
|
||||
macro_rules! check_int4 {
|
||||
($ty:ty, $function:ident) => {{
|
||||
let mut values = [0 as $ty, 1 as $ty, 65536 as $ty, 2147483520_i64 as $ty];
|
||||
assert_eq!(
|
||||
unsafe { $function(values.as_mut_ptr(), values.len()) },
|
||||
0 as $ty
|
||||
);
|
||||
assert_eq!(
|
||||
packed_bytes(&values, 4),
|
||||
[0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0x7f, 0xff, 0xff, 0x80]
|
||||
);
|
||||
}};
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn all_source_types_pack_to_big_endian_integer_bytes() {
|
||||
check_int2!(u16, u16_to_i16);
|
||||
check_int2!(u32, u32_to_i16);
|
||||
check_int2!(u64, u64_to_i16);
|
||||
check_int2!(i16, i16_to_i16);
|
||||
check_int2!(i32, i32_to_i16);
|
||||
check_int2!(i64, i64_to_i16);
|
||||
check_int2!(f32, f32_to_i16);
|
||||
check_int2!(f64, f64_to_i16);
|
||||
check_int4!(u32, u32_to_i32);
|
||||
check_int4!(u64, u64_to_i32);
|
||||
check_int4!(i32, i32_to_i32);
|
||||
check_int4!(i64, i64_to_i32);
|
||||
check_int4!(f32, f32_to_i32);
|
||||
check_int4!(f64, f64_to_i32);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn signed_limits_and_unsigned_overflows_are_checked() {
|
||||
let mut signed = [i64::from(i16::MIN), -1];
|
||||
assert_eq!(unsafe { i64_to_i16(signed.as_mut_ptr(), signed.len()) }, 0);
|
||||
assert_eq!(packed_bytes(&signed, 2), [0x80, 0, 0xff, 0xff]);
|
||||
let mut signed = [i64::from(i32::MIN), i64::from(i32::MAX)];
|
||||
assert_eq!(unsafe { i64_to_i32(signed.as_mut_ptr(), signed.len()) }, 0);
|
||||
assert_eq!(
|
||||
packed_bytes(&signed, 4),
|
||||
[0x80, 0, 0, 0, 0x7f, 0xff, 0xff, 0xff]
|
||||
);
|
||||
|
||||
for value in [32768_u64, u64::MAX] {
|
||||
let mut input = [value];
|
||||
assert_eq!(unsafe { u64_to_i16(input.as_mut_ptr(), 1) }, value);
|
||||
assert_eq!(input, [value]);
|
||||
}
|
||||
for value in [2147483648_u64, u64::MAX] {
|
||||
let mut input = [value];
|
||||
assert_eq!(unsafe { u64_to_i32(input.as_mut_ptr(), 1) }, value);
|
||||
assert_eq!(input, [value]);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn nonfinite_floats_and_rounded_up_f32_limit_are_rejected() {
|
||||
for convert in [f32_to_i16, f32_to_i32] {
|
||||
for value in [f32::NAN, f32::INFINITY, f32::NEG_INFINITY] {
|
||||
let mut input = [value];
|
||||
let result = unsafe { convert(input.as_mut_ptr(), 1) };
|
||||
assert_ne!(result, 0.0);
|
||||
assert_eq!(input[0].to_bits(), value.to_bits());
|
||||
}
|
||||
}
|
||||
for convert in [f64_to_i16, f64_to_i32] {
|
||||
for value in [f64::NAN, f64::INFINITY, f64::NEG_INFINITY] {
|
||||
let mut input = [value];
|
||||
assert_ne!(unsafe { convert(input.as_mut_ptr(), 1) }, 0.0);
|
||||
assert_eq!(input[0].to_bits(), value.to_bits());
|
||||
}
|
||||
}
|
||||
let mut input = [2147483648_f32];
|
||||
assert_eq!(unsafe { f32_to_i32(input.as_mut_ptr(), 1) }, 2147483648_f32);
|
||||
assert_eq!(input, [2147483648_f32]);
|
||||
let mut input = [-2147483648_f32];
|
||||
assert_eq!(unsafe { f32_to_i32(input.as_mut_ptr(), 1) }, 0.0);
|
||||
assert_eq!(packed_bytes(&input, 4), [0x80, 0, 0, 0]);
|
||||
}
|
||||
105
tests/python/test_arrow.py
Normal file
105
tests/python/test_arrow.py
Normal file
|
|
@ -0,0 +1,105 @@
|
|||
"""Public Arrow readers, lifetime management and input validation."""
|
||||
|
||||
import gc
|
||||
import gzip
|
||||
import mmap
|
||||
from pathlib import Path
|
||||
import tempfile
|
||||
from types import SimpleNamespace
|
||||
import unittest
|
||||
from unittest.mock import patch
|
||||
|
||||
import numpy
|
||||
|
||||
from pheon import PheonError, arrow
|
||||
from pheon._native import ffi
|
||||
from test_ffi import layout
|
||||
|
||||
|
||||
class ArrowTests(unittest.TestCase):
|
||||
def test_full_scan_and_selected_reads_own_their_data(self):
|
||||
data = bytearray(layout())
|
||||
full = arrow.read_bytes(data)
|
||||
scan = arrow.scan_bytes(data)
|
||||
cells = scan.field("cells")[0].values
|
||||
ranges = list(
|
||||
zip(
|
||||
cells.field("struct_start_offset").to_pylist(),
|
||||
cells.field("struct_end_offset").to_pylist(),
|
||||
)
|
||||
)
|
||||
selected = arrow.read_cells_bytes(data, ranges)
|
||||
data[:] = b"\0" * len(data)
|
||||
del data
|
||||
gc.collect()
|
||||
self.assertEqual(full.to_pylist(), selected.to_pylist())
|
||||
self.assertEqual(full.field("cell_names")[0].as_py(), ["cell"])
|
||||
self.assertEqual(scan.field("cell_names")[0].as_py(), ["cell"])
|
||||
|
||||
def test_paths_gzip_magic_and_closed_mmap(self):
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
path = Path(directory) / "layout with spaces.gds"
|
||||
path.write_bytes(layout())
|
||||
expected = arrow.read_path(path).to_pylist()
|
||||
with path.open("rb") as stream:
|
||||
with mmap.mmap(stream.fileno(), 0, access=mmap.ACCESS_READ) as buffer:
|
||||
result = arrow.read_bytes(buffer)
|
||||
self.assertEqual(result.to_pylist(), expected)
|
||||
path.write_bytes(gzip.compress(layout()))
|
||||
self.assertEqual(arrow.read_path(path).to_pylist(), expected)
|
||||
|
||||
def test_empty_and_noncontiguous_cell_selections(self):
|
||||
data = layout()
|
||||
empty = arrow.read_cells_bytes(data, [])
|
||||
self.assertEqual(empty.field("cells")[0].as_py(), [])
|
||||
values = numpy.array([[62, 0, len(data) - 4, 0]], dtype=numpy.uint64)[:, ::2]
|
||||
self.assertFalse(values.flags.c_contiguous)
|
||||
self.assertEqual(
|
||||
arrow.read_cells_bytes(data, values).to_pylist(),
|
||||
arrow.read_bytes(data).to_pylist(),
|
||||
)
|
||||
|
||||
def test_bad_inputs_fail_before_importing_arrow(self):
|
||||
with self.assertRaises(PheonError):
|
||||
arrow.read_bytes(b"invalid")
|
||||
with self.assertRaises(PheonError):
|
||||
arrow.scan_bytes(b"")
|
||||
with self.assertRaises(PheonError):
|
||||
arrow.read_cells_bytes(layout(), [[0, 10]])
|
||||
with self.assertRaises(ValueError):
|
||||
arrow.read_bytes(memoryview(layout())[::2])
|
||||
for ranges in [[62, 100], [[-1, 100]], [[1, 2, 3]]]:
|
||||
with self.assertRaises(ValueError):
|
||||
arrow.read_cells_bytes(layout(), ranges)
|
||||
with self.assertRaises(TypeError):
|
||||
arrow.read_cells_bytes(layout(), [[1.5, 2.5]])
|
||||
|
||||
def test_import_failure_releases_both_native_outputs(self):
|
||||
releases = []
|
||||
|
||||
@ffi.callback("void(struct ArrowArray *)")
|
||||
def release_array(value):
|
||||
releases.append("array")
|
||||
value.release = ffi.NULL
|
||||
|
||||
@ffi.callback("void(struct ArrowSchema *)")
|
||||
def release_schema(value):
|
||||
releases.append("schema")
|
||||
value.release = ffi.NULL
|
||||
|
||||
def export(array, schema):
|
||||
array.release = release_array
|
||||
schema.release = release_schema
|
||||
return 0
|
||||
|
||||
def fail_import(*args):
|
||||
raise ValueError("import failed")
|
||||
|
||||
with patch.object(
|
||||
arrow,
|
||||
"pyarrow",
|
||||
SimpleNamespace(Array=SimpleNamespace(_import_from_c=fail_import)),
|
||||
):
|
||||
with self.assertRaisesRegex(ValueError, "import failed"):
|
||||
arrow._export(export)
|
||||
self.assertEqual(releases, ["array", "schema"])
|
||||
70
tests/python/test_ffi.py
Normal file
70
tests/python/test_ffi.py
Normal file
|
|
@ -0,0 +1,70 @@
|
|||
"""Exercise the explicit C ABI declarations against the actual shared library."""
|
||||
import struct
|
||||
import tempfile
|
||||
from pathlib import Path
|
||||
import unittest
|
||||
|
||||
from pheon._native import ffi, lib
|
||||
|
||||
|
||||
def record(tag, data=b""):
|
||||
return struct.pack(">HH", len(data) + 4, tag) + data
|
||||
|
||||
|
||||
def layout():
|
||||
return b"".join([
|
||||
record(0x0002, struct.pack(">h", 600)),
|
||||
record(0x0102, b"\0" * 24),
|
||||
record(0x0206, b"test"),
|
||||
record(0x0305, bytes.fromhex("3e4189374bc6a7f03944b82fa09b5a54")),
|
||||
record(0x0502, b"\0" * 24),
|
||||
record(0x0606, b"cell"),
|
||||
record(0x0700),
|
||||
record(0x0400),
|
||||
])
|
||||
|
||||
|
||||
class FfiTests(unittest.TestCase):
|
||||
def check_export(self, call):
|
||||
array = ffi.new("struct ArrowArray *")
|
||||
schema = ffi.new("struct ArrowSchema *")
|
||||
try:
|
||||
self.assertEqual(call(array, schema), 0)
|
||||
self.assertEqual(lib.last_error_message(), ffi.NULL)
|
||||
self.assertEqual(array.length, 1)
|
||||
self.assertEqual(ffi.string(schema.format), b"+s")
|
||||
self.assertNotEqual(array.release, ffi.NULL)
|
||||
self.assertNotEqual(schema.release, ffi.NULL)
|
||||
self.assertGreaterEqual(array.n_children, 7)
|
||||
self.assertEqual(array.n_children, schema.n_children)
|
||||
self.assertEqual(ffi.string(schema.children[0].name), b"meters_per_db_unit")
|
||||
finally:
|
||||
if array.release != ffi.NULL:
|
||||
array.release(array)
|
||||
if schema.release != ffi.NULL:
|
||||
schema.release(schema)
|
||||
|
||||
def test_scan_selected_read_and_path_exports(self):
|
||||
data = layout()
|
||||
self.check_export(lambda a, s: lib.scan_bytes(data, len(data), a, s))
|
||||
self.check_export(lambda a, s: lib.read_bytes(data, len(data), a, s))
|
||||
# The library header is 62 bytes; the one cell ends just before ENDLIB.
|
||||
ranges = ffi.new("uint64_t[]", [62, len(data) - 4])
|
||||
self.check_export(lambda a, s: lib.read_cells_bytes(data, len(data), ranges, 1, a, s))
|
||||
with tempfile.TemporaryDirectory() as directory:
|
||||
path = Path(directory) / "file with spaces.gds"
|
||||
path.write_bytes(data)
|
||||
self.check_export(lambda a, s: lib.read_path(str(path).encode(), a, s))
|
||||
|
||||
def test_failures_leave_outputs_empty_and_expose_error_message(self):
|
||||
array = ffi.new("struct ArrowArray *")
|
||||
schema = ffi.new("struct ArrowSchema *")
|
||||
self.assertEqual(lib.scan_bytes(ffi.NULL, 0, array, schema), -1)
|
||||
self.assertNotEqual(lib.last_error_message(), ffi.NULL)
|
||||
self.assertIn(b"scan_bytes", ffi.string(lib.last_error_message()))
|
||||
self.assertEqual(array.release, ffi.NULL)
|
||||
self.assertEqual(schema.release, ffi.NULL)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
36
tests/python/test_loader.py
Normal file
36
tests/python/test_loader.py
Normal file
|
|
@ -0,0 +1,36 @@
|
|||
"""Reject incompatible native libraries before exposing callable functions."""
|
||||
|
||||
from pathlib import Path
|
||||
import runpy
|
||||
from types import SimpleNamespace
|
||||
import unittest
|
||||
from unittest.mock import patch
|
||||
|
||||
import pheon._native
|
||||
|
||||
|
||||
class LoaderTests(unittest.TestCase):
|
||||
def load(self, library):
|
||||
with patch("cffi.FFI.dlopen", return_value=library):
|
||||
return runpy.run_path(str(Path(pheon._native.__file__)))
|
||||
|
||||
def test_matching_versions_are_accepted(self):
|
||||
self.load(
|
||||
SimpleNamespace(
|
||||
pheon_abi_version=lambda: 1, pheon_arrow_schema_version=lambda: 1
|
||||
)
|
||||
)
|
||||
|
||||
def test_incompatible_abi_or_schema_is_rejected(self):
|
||||
for abi, schema in [(2, 1), (1, 2)]:
|
||||
with self.assertRaisesRegex(ImportError, "Incompatible Pheon library"):
|
||||
self.load(
|
||||
SimpleNamespace(
|
||||
pheon_abi_version=lambda: abi,
|
||||
pheon_arrow_schema_version=lambda: schema,
|
||||
)
|
||||
)
|
||||
|
||||
def test_unversioned_library_is_rejected(self):
|
||||
with self.assertRaisesRegex(ImportError, "version API"):
|
||||
self.load(SimpleNamespace())
|
||||
66
tests/python/test_packing.py
Normal file
66
tests/python/test_packing.py
Normal file
|
|
@ -0,0 +1,66 @@
|
|||
import unittest
|
||||
|
||||
import numpy as np
|
||||
|
||||
from pheon import pack_int2, pack_int4
|
||||
|
||||
|
||||
class PackingTests(unittest.TestCase):
|
||||
def test_scalars_lists_and_dimensions(self):
|
||||
for pack, width in [(pack_int2, 2), (pack_int4, 4)]:
|
||||
for dtype in [np.int64, np.int32, np.uint64, np.uint32, np.float64, np.float32]:
|
||||
for shape in [(), (1,), (2, 2), (2, 2, 2)]:
|
||||
count = int(np.prod(shape)) if shape else 1
|
||||
data = np.arange(count, dtype=dtype).reshape(shape)
|
||||
before = data.copy()
|
||||
with self.subTest(width=width, dtype=dtype, shape=shape):
|
||||
self.assertEqual(pack(data), data.astype(f">i{width}").tobytes())
|
||||
np.testing.assert_array_equal(data, before)
|
||||
for data in [5, [1, 2, 3], [[1, 2], [3, 4]], [], [[], []]]:
|
||||
with self.subTest(width=width, data=data):
|
||||
self.assertEqual(pack(data), np.asarray(data).astype(f">i{width}").tobytes())
|
||||
|
||||
def test_noncontiguous_readonly_and_endian_inputs(self):
|
||||
original = np.arange(48, dtype=np.int64).reshape(6, 8)
|
||||
readonly = original.copy()
|
||||
readonly.setflags(write=False)
|
||||
for data in [original.T, original[::-1, ::2], np.asfortranarray(original), readonly,
|
||||
original.astype(">i8"), original.astype(">i2"), original.astype(">i4")]:
|
||||
before = data.copy()
|
||||
for pack, width in [(pack_int2, 2), (pack_int4, 4)]:
|
||||
with self.subTest(width=width, strides=data.strides, dtype=data.dtype):
|
||||
self.assertEqual(pack(data), data.astype(f">i{width}").tobytes(order="C"))
|
||||
np.testing.assert_array_equal(data, before)
|
||||
|
||||
def test_signed_limits_and_native_integer_widths(self):
|
||||
for pack, width in [(pack_int2, 2), (pack_int4, 4)]:
|
||||
low, high = -(1 << (8 * width - 1)), (1 << (8 * width - 1)) - 1
|
||||
data = np.array([[low, -1], [0, high]], dtype=np.int64)
|
||||
self.assertEqual(pack(data), data.astype(f">i{width}").tobytes())
|
||||
for dtype in [np.int8, np.uint8, np.int16, np.uint16]:
|
||||
data = np.array([[1, 2], [3, 4]], dtype=dtype)
|
||||
self.assertEqual(pack_int2(data), data.astype(">i2").tobytes())
|
||||
self.assertEqual(pack_int4(data), data.astype(">i4").tobytes())
|
||||
|
||||
def test_failed_conversions_preserve_caller_data(self):
|
||||
for pack, width in [(pack_int2, 2), (pack_int4, 4)]:
|
||||
limit = 1 << (8 * width - 1)
|
||||
for invalid in [limit, -limit - 1]:
|
||||
data = np.array([[1, 2], [3, invalid]], dtype=np.int64)
|
||||
before = data.copy()
|
||||
with self.subTest(width=width, invalid=invalid):
|
||||
with self.assertRaises(ValueError):
|
||||
pack(data)
|
||||
np.testing.assert_array_equal(data, before)
|
||||
for dtype in [np.float32, np.float64]:
|
||||
for invalid in [np.nan, np.inf, -np.inf]:
|
||||
data = np.array([[1, 2], [3, invalid]], dtype=dtype)
|
||||
before = data.copy()
|
||||
with self.subTest(width=width, invalid=invalid, dtype=dtype):
|
||||
with self.assertRaises(ValueError):
|
||||
pack(data)
|
||||
np.testing.assert_array_equal(data, before)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
75
tests/real8.rs
Normal file
75
tests/real8.rs
Normal file
|
|
@ -0,0 +1,75 @@
|
|||
use pheon::basic::{decode_real8, encode_real8, pack_real8};
|
||||
|
||||
#[test]
|
||||
fn normalized_real8_has_known_encodings_and_exact_values() {
|
||||
for (value, expected) in [
|
||||
(0.0, 0),
|
||||
(-0.0, 0),
|
||||
(1.0, 0x4110_0000_0000_0000),
|
||||
(-2.0, 0xc120_0000_0000_0000),
|
||||
(0.5, 0x4080_0000_0000_0000),
|
||||
(0.001, 0x3e41_8937_4bc6_a7f0),
|
||||
(1e-9, 0x3944_b82f_a09b_5a54),
|
||||
(2_f64.powi(-260), 0x0010_0000_0000_0000),
|
||||
] {
|
||||
let bits = encode_real8(value).unwrap();
|
||||
assert_eq!(bits, expected, "{value:e}");
|
||||
assert_eq!(decode_real8(bits), value);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn real8_round_trips_each_supported_binary_exponent_and_mantissa_boundary() {
|
||||
for exponent in -260..=251_i32 {
|
||||
for mantissa in [
|
||||
0,
|
||||
1,
|
||||
0x0008_0000_0000_0000,
|
||||
0x000f_ffff_ffff_fffe,
|
||||
0x000f_ffff_ffff_ffff,
|
||||
] {
|
||||
for sign in [0, 1_u64 << 63] {
|
||||
let ieee = sign | (((exponent + 1023) as u64) << 52) | mantissa;
|
||||
let value = f64::from_bits(ieee);
|
||||
let encoded = encode_real8(value).unwrap();
|
||||
assert_ne!(encoded & 0x00f0_0000_0000_0000, 0, "{value:e}");
|
||||
assert_eq!(decode_real8(encoded).to_bits(), ieee, "{value:e}");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn real8_underflow_is_canonical_and_overflow_is_an_error() {
|
||||
let minimum = 2_f64.powi(-260);
|
||||
let maximum_exclusive = 2_f64.powi(252);
|
||||
for magnitude in [
|
||||
0.0,
|
||||
f64::from_bits(1),
|
||||
f64::MIN_POSITIVE,
|
||||
1e-90,
|
||||
1e-80,
|
||||
f64::from_bits(minimum.to_bits() - 1),
|
||||
] {
|
||||
for value in [magnitude, -magnitude] {
|
||||
assert_eq!(encode_real8(value).unwrap(), 0, "{value:e}");
|
||||
}
|
||||
}
|
||||
let largest = f64::from_bits(maximum_exclusive.to_bits() - 1);
|
||||
assert_eq!(encode_real8(largest).unwrap(), 0x7fff_ffff_ffff_fff8);
|
||||
assert_eq!(decode_real8(encode_real8(largest).unwrap()), largest);
|
||||
for value in [
|
||||
maximum_exclusive,
|
||||
-maximum_exclusive,
|
||||
f64::MAX,
|
||||
-f64::MAX,
|
||||
f64::INFINITY,
|
||||
f64::NEG_INFINITY,
|
||||
f64::NAN,
|
||||
] {
|
||||
assert!(encode_real8(value).is_err(), "{value}");
|
||||
let mut buffer = [0x55; 8];
|
||||
assert!(pack_real8(&mut buffer, value).is_err());
|
||||
assert_eq!(buffer, [0x55; 8]);
|
||||
}
|
||||
}
|
||||
1248
tests/review.rs
Normal file
1248
tests/review.rs
Normal file
File diff suppressed because it is too large
Load diff
633
tests/review/reports.rs
Normal file
633
tests/review/reports.rs
Normal file
|
|
@ -0,0 +1,633 @@
|
|||
use super::*;
|
||||
use pheon::review::{
|
||||
DisplayFilter, Scope,
|
||||
report::{ReportInputs, ReportOptions, failure_report},
|
||||
};
|
||||
use serde_json::{Value, json};
|
||||
|
||||
fn inputs() -> ReportInputs {
|
||||
ReportInputs {
|
||||
old: Some("before.gds".into()),
|
||||
new: Some("after.gds".into()),
|
||||
}
|
||||
}
|
||||
|
||||
fn report(old: &[u8], new: &[u8], options: &ReportOptions) -> Value {
|
||||
let a = Document::parse(old).unwrap();
|
||||
let b = Document::parse(new).unwrap();
|
||||
Comparison::between(&a, &b).json_report(&a, &b, &inputs(), options)
|
||||
}
|
||||
|
||||
fn unknown(geometry: Vec<u8>) -> Vec<u8> {
|
||||
let mut object = geometry;
|
||||
object.truncate(object.len() - 4);
|
||||
record(&mut object, 0x7f02, &[0, 42]);
|
||||
record(&mut object, RTAG_ENDEL, &[]);
|
||||
layout(&[("CHIP", vec![object])])
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reports_preserve_fixture_results_totals_and_replacement_links() {
|
||||
for pair in corpus() {
|
||||
let r = report(&pair.old, &pair.new, &ReportOptions::default());
|
||||
assert_eq!(r["schema_version"], 1);
|
||||
assert_eq!(r["comparison_profile"], "klamath-object-v2");
|
||||
assert_eq!(r["producer"]["version"], env!("CARGO_PKG_VERSION"));
|
||||
assert_eq!(r["status"], "complete", "{}", pair.name);
|
||||
assert_eq!(
|
||||
r["exit_code"],
|
||||
if pair.changed_cells + pair.metadata == 0 {
|
||||
0
|
||||
} else {
|
||||
1
|
||||
}
|
||||
);
|
||||
assert_eq!(
|
||||
r["summary"]["changed_cells"],
|
||||
pair.changed_cells.to_string()
|
||||
);
|
||||
assert_eq!(r["summary"]["added_objects"], pair.added.to_string());
|
||||
assert_eq!(r["summary"]["removed_objects"], pair.removed.to_string());
|
||||
assert_eq!(
|
||||
r["summary"]["layer_name_changes"],
|
||||
pair.metadata.to_string()
|
||||
);
|
||||
assert_eq!(r["report_selection"]["truncated"], false);
|
||||
for cell in r["cell_changes"].as_array().unwrap() {
|
||||
for replacement in cell["replacements"].as_array().unwrap() {
|
||||
assert!(
|
||||
cell["removed"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.any(|o| o["id"] == replacement["removed"])
|
||||
);
|
||||
assert!(
|
||||
cell["added"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.any(|o| o["id"] == replacement["added"])
|
||||
);
|
||||
}
|
||||
}
|
||||
assert_eq!(r, report(&pair.old, &pair.new, &ReportOptions::default()));
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn incomplete_reports_distinguish_known_differences_and_include_structured_locations() {
|
||||
let a = unknown(square());
|
||||
let same = report(&a, &a, &ReportOptions::default());
|
||||
assert_eq!(same["status"], "incomplete");
|
||||
assert_eq!(same["result"], "unknown");
|
||||
assert_eq!(same["exit_code"], 2);
|
||||
assert_eq!(same["summary"]["counts"], "observed");
|
||||
let diagnostic = &same["diagnostics"][0];
|
||||
assert_eq!(diagnostic["code"], "unsupported_record");
|
||||
assert_eq!(diagnostic["side"], "old");
|
||||
assert_eq!(diagnostic["cell"], "CHIP");
|
||||
assert_eq!(diagnostic["layer"], json!({"number":1,"purpose":0}));
|
||||
let offset: usize = diagnostic["byte_offset"].as_str().unwrap().parse().unwrap();
|
||||
assert_eq!(&a[offset + 2..offset + 4], &0x7f02_u16.to_be_bytes());
|
||||
let changed = report(&a, &unknown(triangle()), &ReportOptions::default());
|
||||
assert_eq!(changed["status"], "incomplete");
|
||||
assert_eq!(changed["result"], "different");
|
||||
assert_eq!(changed["exit_code"], 2);
|
||||
assert_eq!(
|
||||
changed["cell_changes"][0]["removed"][0]["fields"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.last()
|
||||
.unwrap()["payload_hex"],
|
||||
"0x002a"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn future_layer_metadata_remains_incomplete_under_geometry_scopes() {
|
||||
for location in ["CHIP", "legend"] {
|
||||
let bytes = if location == "CHIP" {
|
||||
layout(&[(
|
||||
"CHIP",
|
||||
vec![square(), label((900, 7), "KLAMATH_LAYER_NAMES_V2")],
|
||||
)])
|
||||
} else {
|
||||
layout(&[
|
||||
("CHIP", vec![square()]),
|
||||
("legend", vec![label((900, 7), "KLAMATH_LAYER_NAMES_V2")]),
|
||||
])
|
||||
};
|
||||
let source = Document::parse(&bytes).unwrap().diagnostics[0].offset;
|
||||
for scope in [
|
||||
Scope::default(),
|
||||
Scope {
|
||||
layer: Some((1, 0)),
|
||||
..Default::default()
|
||||
},
|
||||
Scope {
|
||||
layer: Some((999, 0)),
|
||||
..Default::default()
|
||||
},
|
||||
Scope {
|
||||
top: Some("CHIP".into()),
|
||||
..Default::default()
|
||||
},
|
||||
Scope {
|
||||
cell: Some("CHIP".into()),
|
||||
..Default::default()
|
||||
},
|
||||
Scope {
|
||||
top: Some("CHIP".into()),
|
||||
layer: Some((1, 0)),
|
||||
..Default::default()
|
||||
},
|
||||
Scope {
|
||||
cell: Some("CHIP".into()),
|
||||
layer: Some((1, 0)),
|
||||
..Default::default()
|
||||
},
|
||||
] {
|
||||
let doc = Document::parse(&bytes)
|
||||
.unwrap()
|
||||
.selected(&scope, false)
|
||||
.unwrap();
|
||||
assert_eq!(doc.diagnostics.len(), 1, "{scope:?}");
|
||||
let diagnostic = &doc.diagnostics[0];
|
||||
assert_eq!(diagnostic.code, "unsupported_metadata_version");
|
||||
assert_eq!(diagnostic.cell.as_deref(), Some(location));
|
||||
assert_eq!(diagnostic.layer, Some((900, 7)));
|
||||
assert_eq!(diagnostic.offset, source);
|
||||
let diff = Comparison::between(&doc, &doc);
|
||||
assert_eq!(diff.exit_code(), 2);
|
||||
assert!(!diff.is_equal());
|
||||
assert!(diff.text(0).contains("INCOMPLETE"));
|
||||
let json = diff.json_report(&doc, &doc, &inputs(), &ReportOptions::default());
|
||||
assert_eq!(json["status"], "incomplete");
|
||||
assert_eq!(json["result"], "unknown");
|
||||
assert_eq!(json["exit_code"], 2);
|
||||
assert_eq!(json["diagnostics"].as_array().unwrap().len(), 2);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn json_is_unbounded_by_default_and_explicit_filters_do_not_change_totals() {
|
||||
let a = layout(&[("CHIP", vec![])]);
|
||||
let b = layout(&[("CHIP", vec![square(); 120])]);
|
||||
let full = report(&a, &b, &ReportOptions::default());
|
||||
assert_eq!(
|
||||
full["cell_changes"][0]["added"].as_array().unwrap().len(),
|
||||
120
|
||||
);
|
||||
let limited = report(
|
||||
&a,
|
||||
&b,
|
||||
&ReportOptions {
|
||||
max_objects: Some(1),
|
||||
..Default::default()
|
||||
},
|
||||
);
|
||||
assert_eq!(limited["summary"], full["summary"]);
|
||||
assert_eq!(limited["exit_code"], 1);
|
||||
assert_eq!(limited["report_selection"]["truncated"], true);
|
||||
assert_eq!(limited["report_selection"]["limited_objects"], "119");
|
||||
assert_eq!(limited["report_selection"]["emitted_objects"], "1");
|
||||
let filtered = report(
|
||||
&a,
|
||||
&b,
|
||||
&ReportOptions {
|
||||
filter: DisplayFilter {
|
||||
cell: Some("absent".into()),
|
||||
layer: None,
|
||||
},
|
||||
..Default::default()
|
||||
},
|
||||
);
|
||||
assert_eq!(filtered["summary"], full["summary"]);
|
||||
assert_eq!(filtered["cell_changes"], json!([]));
|
||||
assert_eq!(filtered["report_selection"]["filtered_cells"], "1");
|
||||
assert_eq!(filtered["report_selection"]["filtered_objects"], "120");
|
||||
let filtered = report(
|
||||
&a,
|
||||
&b,
|
||||
&ReportOptions {
|
||||
filter: DisplayFilter {
|
||||
cell: None,
|
||||
layer: Some((2, 0)),
|
||||
},
|
||||
..Default::default()
|
||||
},
|
||||
);
|
||||
assert_eq!(filtered["summary"], full["summary"]);
|
||||
assert_eq!(filtered["report_selection"]["filtered_objects"], "120");
|
||||
assert_eq!(filtered["cell_changes"][0]["added"], json!([]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn typed_evidence_preserves_defaults_properties_bytes_and_real_encodings() {
|
||||
let mut a = reference("leaf", 0, 1);
|
||||
a.truncate(a.len() - 4);
|
||||
record(&mut a, RTAG_MAG, &0x4110000000000000_u64.to_be_bytes());
|
||||
record(&mut a, RTAG_PROPATTR, &17_u16.to_be_bytes());
|
||||
record(&mut a, RTAG_PROPVALUE, &[0xff, 0xfe]);
|
||||
record(&mut a, RTAG_PROPATTR, &17_u16.to_be_bytes());
|
||||
record(&mut a, RTAG_PROPVALUE, &[0xff, 0xfe]);
|
||||
record(&mut a, RTAG_ENDEL, &[]);
|
||||
let mut b = a.clone();
|
||||
let mag = Document::parse(&layout(&[("CHIP", vec![a.clone()]), ("leaf", vec![])]))
|
||||
.unwrap()
|
||||
.records
|
||||
.into_iter()
|
||||
.find(|r| r.tag == RTAG_MAG)
|
||||
.unwrap()
|
||||
.offset;
|
||||
// Replace the REAL8 payload within the object, retaining the same decoded value.
|
||||
let within = a
|
||||
.windows(8)
|
||||
.position(|v| v == 0x4110000000000000_u64.to_be_bytes())
|
||||
.unwrap();
|
||||
b[within..within + 8].copy_from_slice(&0x4201000000000000_u64.to_be_bytes());
|
||||
let a = layout(&[("CHIP", vec![a]), ("leaf", vec![])]);
|
||||
let b = layout(&[("CHIP", vec![b]), ("leaf", vec![])]);
|
||||
let r = report(&a, &b, &ReportOptions::default());
|
||||
let replacement = &r["cell_changes"][0]["replacements"][0];
|
||||
assert_eq!(replacement["match_rule"], "unique_kind_target");
|
||||
let change = &replacement["field_changes"][0];
|
||||
assert_eq!(change["tag"], RTAG_MAG);
|
||||
assert_eq!(change["before"]["value"], change["after"]["value"]);
|
||||
assert_ne!(
|
||||
change["before"]["payload_hex"],
|
||||
change["after"]["payload_hex"]
|
||||
);
|
||||
let removed = &r["cell_changes"][0]["removed"][0];
|
||||
assert_eq!(removed["properties"].as_array().unwrap().len(), 2);
|
||||
assert_eq!(removed["properties"][0]["attribute"], 17);
|
||||
assert_eq!(removed["properties"][0]["value"], Value::Null);
|
||||
assert_eq!(removed["properties"][0]["payload_hex"], "0xfffe");
|
||||
let offset: usize = removed["source"]["byte_offset"]
|
||||
.as_str()
|
||||
.unwrap()
|
||||
.parse()
|
||||
.unwrap();
|
||||
assert!(offset < mag);
|
||||
let end: usize = removed["source"]["end_offset"]
|
||||
.as_str()
|
||||
.unwrap()
|
||||
.parse()
|
||||
.unwrap();
|
||||
assert_eq!(&a[end - 4..end], &[0, 4, 17, 0]);
|
||||
|
||||
let mut path = square();
|
||||
path[2..4].copy_from_slice(&RTAG_PATH.to_be_bytes());
|
||||
let mut width = path.clone();
|
||||
width.truncate(width.len() - 4);
|
||||
record(&mut width, RTAG_WIDTH, &0_i32.to_be_bytes());
|
||||
record(&mut width, RTAG_ENDEL, &[]);
|
||||
let r = report(
|
||||
&layout(&[("CHIP", vec![path])]),
|
||||
&layout(&[("CHIP", vec![width])]),
|
||||
&ReportOptions::default(),
|
||||
);
|
||||
let change = &r["cell_changes"][0]["replacements"][0]["field_changes"][0];
|
||||
assert_eq!(change["tag"], RTAG_WIDTH);
|
||||
assert_eq!(change["before"], Value::Null);
|
||||
assert_eq!(change["after"]["value"], json!([0]));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hierarchy_reports_shared_ancestors_and_symbolic_arrays() {
|
||||
let options = ReportOptions {
|
||||
hierarchy: true,
|
||||
..Default::default()
|
||||
};
|
||||
let r = report(&shared(square()), &shared(triangle()), &options);
|
||||
let graph = &r["hierarchy"];
|
||||
assert_eq!(graph["nodes"].as_array().unwrap().len(), 4);
|
||||
assert_eq!(
|
||||
graph["nodes"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.find(|n| n["cell"] == "CHIP")
|
||||
.unwrap()["change"],
|
||||
"affected"
|
||||
);
|
||||
assert_eq!(
|
||||
graph["nodes"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.find(|n| n["cell"] == "leaf")
|
||||
.unwrap()["change"],
|
||||
"direct"
|
||||
);
|
||||
let edge = graph["edges"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.find(|e| e["parent"] == "right")
|
||||
.unwrap();
|
||||
assert_eq!(edge["before_count"], "3");
|
||||
assert_eq!(edge["reference_changed"], false);
|
||||
let bytes = shared(square());
|
||||
let scope = Scope {
|
||||
cell: Some("CHIP".into()),
|
||||
..Default::default()
|
||||
};
|
||||
let doc = Document::parse(&bytes)
|
||||
.unwrap()
|
||||
.selected(&scope, false)
|
||||
.unwrap();
|
||||
let r = Comparison::between(&doc, &doc).json_report(&doc, &doc, &inputs(), &options);
|
||||
assert_eq!(r["scope"]["cell"], "CHIP");
|
||||
assert_eq!(
|
||||
r["hierarchy"]["nodes"]
|
||||
.as_array()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.find(|n| n["cell"] == "left")
|
||||
.unwrap()["after"],
|
||||
"outside_scope"
|
||||
);
|
||||
let dangling = layout(&[("CHIP", vec![reference("missing", 0, 1)])]);
|
||||
let r = report(&dangling, &dangling, &options);
|
||||
assert_eq!(r["diagnostics"][0]["code"], "unresolved_reference");
|
||||
assert_eq!(r["diagnostics"][0]["target"], "missing");
|
||||
assert_eq!(r["hierarchy"]["nodes"][1]["after"], "unresolved");
|
||||
let cycle = layout(&[("CHIP", vec![reference("CHIP", 0, 1)])]);
|
||||
assert_eq!(
|
||||
report(&cycle, &cycle, &options)["diagnostics"][0]["code"],
|
||||
"hierarchy_cycle"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn library_attributes_empty_cells_units_and_absence_are_explicit() {
|
||||
let a = layout(&[]);
|
||||
let b = layout(&[("empty", vec![])]);
|
||||
let r = report(&a, &b, &ReportOptions::default());
|
||||
assert_eq!(r["cell_changes"][0]["before"], Value::Null);
|
||||
assert_eq!(r["cell_changes"][0]["after"]["attributes"], json!([]));
|
||||
let mut b = b;
|
||||
let end = Document::parse(&b).unwrap().cells["empty"].end_offset;
|
||||
let mut attribute = Vec::new();
|
||||
record(&mut attribute, RTAG_STRCLASS, &[0, 1]);
|
||||
b.splice(end..end, attribute);
|
||||
let r = report(&layout(&[("empty", vec![])]), &b, &ReportOptions::default());
|
||||
assert_eq!(
|
||||
r["cell_changes"][0]["after"]["attributes"][0]["value"],
|
||||
json!([1])
|
||||
);
|
||||
assert_eq!(r["inputs"]["old"]["units"]["encoding"], "real8");
|
||||
let doc = Document::parse(&a).unwrap();
|
||||
let absent = doc.empty_like();
|
||||
let r = Comparison::between(&absent, &doc).json_report(
|
||||
&absent,
|
||||
&doc,
|
||||
&inputs(),
|
||||
&ReportOptions::default(),
|
||||
);
|
||||
assert_eq!(r["inputs"]["old"]["present"], false);
|
||||
assert_eq!(r["inputs"]["old"]["units"], Value::Null);
|
||||
assert_eq!(
|
||||
r["library_changes"],
|
||||
json!([{"field":"presence","tag":null,"before":false,"after":true}])
|
||||
);
|
||||
let mut b = a.clone();
|
||||
let units = doc
|
||||
.records
|
||||
.iter()
|
||||
.find(|r| r.tag == RTAG_UNITS)
|
||||
.unwrap()
|
||||
.offset;
|
||||
b[units + 12..units + 20].copy_from_slice(
|
||||
&pheon::basic::encode_real8(2e-9)
|
||||
.unwrap()
|
||||
.to_be_bytes(),
|
||||
);
|
||||
let r = report(&a, &b, &ReportOptions::default());
|
||||
assert_eq!(r["library_changes"][0]["tag"], RTAG_UNITS);
|
||||
assert_ne!(r["inputs"]["old"]["units"], r["inputs"]["new"]["units"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn reports_keep_extreme_coordinates_unsigned_layers_and_timestamp_equality() {
|
||||
let a = layout(&[("quoted\"\\\n日本", vec![])]);
|
||||
let mut shape = polygon(&[
|
||||
[i32::MIN, i32::MIN],
|
||||
[i32::MAX, i32::MIN],
|
||||
[i32::MAX, i32::MAX],
|
||||
[i32::MIN, i32::MAX],
|
||||
[i32::MIN, i32::MIN],
|
||||
]);
|
||||
shape[8..10].copy_from_slice(&u16::MAX.to_be_bytes());
|
||||
let b = layout(&[("quoted\"\\\n日本", vec![shape])]);
|
||||
let r = report(&a, &b, &ReportOptions::default());
|
||||
let object = &r["cell_changes"][0]["added"][0];
|
||||
assert_eq!(object["layer"]["number"], u16::MAX);
|
||||
assert_eq!(
|
||||
object["bounds"],
|
||||
json!([i32::MIN, i32::MIN, i32::MAX, i32::MAX])
|
||||
);
|
||||
let encoded = serde_json::to_string(&r).unwrap();
|
||||
assert_eq!(serde_json::from_str::<Value>(&encoded).unwrap(), r);
|
||||
let mut times = b.clone();
|
||||
let doc = Document::parse(&b).unwrap();
|
||||
for record in doc
|
||||
.records
|
||||
.iter()
|
||||
.filter(|r| matches!(r.tag, RTAG_BGNLIB | RTAG_BGNSTR))
|
||||
{
|
||||
times[record.offset + 4..record.offset + 28].fill(1);
|
||||
}
|
||||
let r = report(&b, ×, &ReportOptions::default());
|
||||
assert_eq!(r["result"], "equal");
|
||||
assert_eq!(r["exit_code"], 0);
|
||||
}
|
||||
|
||||
#[cfg(unix)]
|
||||
#[test]
|
||||
fn cli_preserves_non_utf8_path_bytes_and_literal_option_names() {
|
||||
use std::os::unix::ffi::OsStringExt;
|
||||
let directory = std::env::temp_dir().join(format!("pheon json paths {}", std::process::id()));
|
||||
fs::create_dir_all(&directory).unwrap();
|
||||
struct Cleanup(PathBuf);
|
||||
impl Drop for Cleanup {
|
||||
fn drop(&mut self) {
|
||||
let _ = fs::remove_dir_all(&self.0);
|
||||
}
|
||||
}
|
||||
let _cleanup = Cleanup(directory.clone());
|
||||
let path = directory.join(std::ffi::OsString::from_vec(b"file\xff.gds".to_vec()));
|
||||
fs::write(&path, layout(&[])).unwrap();
|
||||
let output = Command::new(env!("CARGO_BIN_EXE_pheon"))
|
||||
.arg("diff")
|
||||
.args(["--format", "json", "--"])
|
||||
.arg(&path)
|
||||
.arg(&path)
|
||||
.output()
|
||||
.unwrap();
|
||||
assert_eq!(output.status.code(), Some(0));
|
||||
let r: Value = serde_json::from_slice(&output.stdout).unwrap();
|
||||
assert_eq!(r["inputs"]["old"]["path"], Value::Null);
|
||||
let expected = "0x".to_string()
|
||||
+ &path
|
||||
.as_os_str()
|
||||
.as_encoded_bytes()
|
||||
.iter()
|
||||
.map(|b| format!("{b:02x}"))
|
||||
.collect::<String>();
|
||||
assert_eq!(r["inputs"]["old"]["path_encoded_hex"], expected);
|
||||
for name in ["--format", "json"] {
|
||||
fs::write(directory.join(name), layout(&[])).unwrap();
|
||||
}
|
||||
let output = Command::new(env!("CARGO_BIN_EXE_pheon"))
|
||||
.current_dir(&directory)
|
||||
.args(["diff", "--", "--format", "json"])
|
||||
.output()
|
||||
.unwrap();
|
||||
assert_eq!(output.status.code(), Some(0));
|
||||
assert!(
|
||||
String::from_utf8(output.stdout)
|
||||
.unwrap()
|
||||
.starts_with("profile ")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn machine_reports_match_versioned_goldens() {
|
||||
let options = ReportOptions {
|
||||
hierarchy: true,
|
||||
..Default::default()
|
||||
};
|
||||
let equal = layout(&[("CHIP", vec![square()])]);
|
||||
let metadata = corpus()
|
||||
.into_iter()
|
||||
.find(|p| p.name == "layer name only")
|
||||
.unwrap();
|
||||
let samples = [
|
||||
("equal", report(&equal, &equal, &ReportOptions::default())),
|
||||
(
|
||||
"geometry",
|
||||
report(&shared(square()), &shared(triangle()), &options),
|
||||
),
|
||||
(
|
||||
"metadata",
|
||||
report(&metadata.old, &metadata.new, &ReportOptions::default()),
|
||||
),
|
||||
(
|
||||
"incomplete",
|
||||
report(
|
||||
&unknown(square()),
|
||||
&unknown(square()),
|
||||
&ReportOptions::default(),
|
||||
),
|
||||
),
|
||||
(
|
||||
"failed",
|
||||
failure_report(
|
||||
&inputs(),
|
||||
&Scope::default(),
|
||||
&ReportOptions::default(),
|
||||
"invalid_input",
|
||||
"truncated record",
|
||||
Some("new"),
|
||||
),
|
||||
),
|
||||
];
|
||||
for (name, mut actual) in samples {
|
||||
actual["producer"]["version"] = json!("test");
|
||||
let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
|
||||
.join(format!("tests/golden/report-{name}.json"));
|
||||
if std::env::var_os("PHEON_UPDATE_REPORT_GOLDENS").is_some() {
|
||||
fs::write(&path, serde_json::to_string_pretty(&actual).unwrap() + "\n").unwrap();
|
||||
}
|
||||
let expected: Value = serde_json::from_slice(&fs::read(&path).unwrap()).unwrap();
|
||||
assert_eq!(actual, expected, "{name}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cli_emits_json_for_success_input_errors_scope_errors_and_argument_errors() {
|
||||
let directory = std::env::temp_dir().join(format!("pheon json {}", std::process::id()));
|
||||
fs::create_dir_all(&directory).unwrap();
|
||||
struct Cleanup(PathBuf);
|
||||
impl Drop for Cleanup {
|
||||
fn drop(&mut self) {
|
||||
let _ = fs::remove_dir_all(&self.0);
|
||||
}
|
||||
}
|
||||
let _cleanup = Cleanup(directory.clone());
|
||||
let a = directory.join("before file.gds");
|
||||
let b = directory.join("after file.gds");
|
||||
fs::write(&a, shared(square())).unwrap();
|
||||
fs::write(&b, shared(triangle())).unwrap();
|
||||
let command = |extra: &[&str]| {
|
||||
let output = Command::new(env!("CARGO_BIN_EXE_pheon"))
|
||||
.arg("diff")
|
||||
.arg(&a)
|
||||
.arg(&b)
|
||||
.args(["--format", "json"])
|
||||
.args(extra)
|
||||
.output()
|
||||
.unwrap();
|
||||
assert!(output.stderr.is_empty(), "{:?}", output.stderr);
|
||||
let report: Value = serde_json::from_slice(&output.stdout).unwrap();
|
||||
assert_eq!(
|
||||
output.status.code().unwrap(),
|
||||
report["exit_code"].as_i64().unwrap() as i32
|
||||
);
|
||||
report
|
||||
};
|
||||
let full = command(&["--hierarchy", "graph"]);
|
||||
assert_eq!(full["result"], "different");
|
||||
assert!(full["hierarchy"].is_object());
|
||||
let limited = command(&["--max-changes", "0"]);
|
||||
assert_eq!(limited["summary"], full["summary"]);
|
||||
assert_eq!(limited["report_selection"]["emitted_objects"], "0");
|
||||
for extra in [
|
||||
&["--top", "missing"][..],
|
||||
&["--unknown"],
|
||||
&["--max-changes", "x"],
|
||||
&["--hierarchy", "mermaid"],
|
||||
&["--depth", "3"],
|
||||
] {
|
||||
let failure = command(extra);
|
||||
assert_eq!(failure["status"], "failed");
|
||||
assert_eq!(failure["result"], "unknown");
|
||||
assert_eq!(failure["summary"], Value::Null);
|
||||
}
|
||||
fs::write(&b, b"invalid").unwrap();
|
||||
let invalid = command(&[]);
|
||||
assert_eq!(invalid["diagnostics"][0]["code"], "invalid_input");
|
||||
assert_eq!(invalid["diagnostics"][0]["side"], "new");
|
||||
assert_eq!(invalid["inputs"]["new"]["path"], b.to_str().unwrap());
|
||||
fs::remove_file(&b).unwrap();
|
||||
assert_eq!(command(&[])["diagnostics"][0]["code"], "io_error");
|
||||
fs::write(&b, fs::read(&a).unwrap()).unwrap();
|
||||
assert_eq!(command(&[])["result"], "equal");
|
||||
fs::write(&b, unknown(square())).unwrap();
|
||||
assert_eq!(command(&[])["status"], "incomplete");
|
||||
fs::write(
|
||||
&b,
|
||||
layout(&[
|
||||
("CHIP", vec![square()]),
|
||||
("legend", vec![label((900, 7), "KLAMATH_LAYER_NAMES_V2")]),
|
||||
]),
|
||||
)
|
||||
.unwrap();
|
||||
for flags in [
|
||||
&["--layer", "1/0"][..],
|
||||
&["--top", "CHIP"],
|
||||
&["--cell", "CHIP", "--layer", "1/0"],
|
||||
] {
|
||||
let report = command(flags);
|
||||
assert_eq!(report["status"], "incomplete");
|
||||
assert_eq!(report["exit_code"], 2);
|
||||
assert_eq!(
|
||||
report["diagnostics"][0]["code"],
|
||||
"unsupported_metadata_version"
|
||||
);
|
||||
}
|
||||
}
|
||||
768
tests/selective_reads.rs
Normal file
768
tests/selective_reads.rs
Normal file
|
|
@ -0,0 +1,768 @@
|
|||
mod common;
|
||||
|
||||
use arrow_array::ffi::{FFI_ArrowArray, FFI_ArrowSchema, from_ffi};
|
||||
use arrow_array::{
|
||||
Array, BooleanArray, Float64Array, Int16Array, Int32Array, ListArray, StringArray, StructArray,
|
||||
UInt32Array, UInt64Array,
|
||||
};
|
||||
use common::{library_header, record};
|
||||
use pheon::{
|
||||
basic::encode_real8,
|
||||
last_error_message,
|
||||
library::{read_library, read_selected_library, scan_library},
|
||||
read_cells_bytes, read_path, records, scan_bytes,
|
||||
};
|
||||
use std::{
|
||||
ffi::{CStr, CString},
|
||||
ptr,
|
||||
};
|
||||
|
||||
fn xy(values: &[i32]) -> Vec<u8> {
|
||||
values.iter().flat_map(|v| v.to_be_bytes()).collect()
|
||||
}
|
||||
|
||||
fn fixture() -> Vec<u8> {
|
||||
let mut bytes = library_header();
|
||||
record(&mut bytes, records::RTAG_BGNSTR, &[0; 24]);
|
||||
record(&mut bytes, records::RTAG_STRNAME, b"top\0");
|
||||
record(&mut bytes, records::RTAG_SREF, &[]);
|
||||
record(&mut bytes, records::RTAG_SNAME, b"leaf");
|
||||
record(&mut bytes, records::RTAG_XY, &xy(&[3, -4]));
|
||||
record(&mut bytes, records::RTAG_PROPATTR, &1_i16.to_be_bytes());
|
||||
record(&mut bytes, records::RTAG_PROPVALUE, b"value\0");
|
||||
record(&mut bytes, records::RTAG_ENDEL, &[]);
|
||||
record(&mut bytes, records::RTAG_AREF, &[]);
|
||||
record(&mut bytes, records::RTAG_SNAME, b"leaf");
|
||||
record(&mut bytes, records::RTAG_STRANS, &[0x80, 0]);
|
||||
record(
|
||||
&mut bytes,
|
||||
records::RTAG_MAG,
|
||||
&encode_real8(2.0).unwrap().to_be_bytes(),
|
||||
);
|
||||
record(
|
||||
&mut bytes,
|
||||
records::RTAG_ANGLE,
|
||||
&encode_real8(90.0).unwrap().to_be_bytes(),
|
||||
);
|
||||
record(&mut bytes, records::RTAG_COLROW, &[0, 2, 0, 3]);
|
||||
record(&mut bytes, records::RTAG_XY, &xy(&[-5, -7, 15, -7, -5, 23]));
|
||||
record(&mut bytes, records::RTAG_ENDEL, &[]);
|
||||
record(&mut bytes, records::RTAG_ENDSTR, &[]);
|
||||
record(&mut bytes, records::RTAG_BGNSTR, &[0; 24]);
|
||||
record(&mut bytes, records::RTAG_STRNAME, b"leaf");
|
||||
record(&mut bytes, records::RTAG_BOUNDARY, &[]);
|
||||
record(&mut bytes, records::RTAG_LAYER, &1_i16.to_be_bytes());
|
||||
record(&mut bytes, records::RTAG_DATATYPE, &0_i16.to_be_bytes());
|
||||
record(
|
||||
&mut bytes,
|
||||
records::RTAG_XY,
|
||||
&xy(&[0, 0, 10, 0, 10, 10, 0, 10, 0, 0]),
|
||||
);
|
||||
record(&mut bytes, records::RTAG_ENDEL, &[]);
|
||||
record(&mut bytes, records::RTAG_ENDSTR, &[]);
|
||||
record(&mut bytes, records::RTAG_ENDLIB, &[]);
|
||||
bytes
|
||||
}
|
||||
|
||||
fn list_struct(array: &StructArray, name: &str, row: usize) -> StructArray {
|
||||
let list = array
|
||||
.column_by_name(name)
|
||||
.unwrap()
|
||||
.as_any()
|
||||
.downcast_ref::<ListArray>()
|
||||
.unwrap();
|
||||
list.value(row)
|
||||
.as_any()
|
||||
.downcast_ref::<StructArray>()
|
||||
.unwrap()
|
||||
.clone()
|
||||
}
|
||||
|
||||
fn aref_fixture(origin: [i32; 2], column: [i32; 2], row: [i32; 2], counts: [i16; 2]) -> Vec<u8> {
|
||||
let mut bytes = library_header();
|
||||
record(&mut bytes, records::RTAG_BGNSTR, &[0; 24]);
|
||||
record(&mut bytes, records::RTAG_STRNAME, b"top\0");
|
||||
record(&mut bytes, records::RTAG_AREF, &[]);
|
||||
record(&mut bytes, records::RTAG_SNAME, b"leaf");
|
||||
let counts: Vec<u8> = counts.into_iter().flat_map(i16::to_be_bytes).collect();
|
||||
record(&mut bytes, records::RTAG_COLROW, &counts);
|
||||
record(
|
||||
&mut bytes,
|
||||
records::RTAG_XY,
|
||||
&xy(&[origin[0], origin[1], column[0], column[1], row[0], row[1]]),
|
||||
);
|
||||
record(&mut bytes, records::RTAG_ENDEL, &[]);
|
||||
record(&mut bytes, records::RTAG_ENDSTR, &[]);
|
||||
record(&mut bytes, records::RTAG_ENDLIB, &[]);
|
||||
bytes
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn aref_pitches_use_wide_coordinate_differences_in_full_reads_and_scans() {
|
||||
let bytes = aref_fixture(
|
||||
[i32::MIN, i32::MAX],
|
||||
[i32::MAX - 1, i32::MIN + 1],
|
||||
[i32::MIN, i32::MIN + 1],
|
||||
[2, 2],
|
||||
);
|
||||
let full_cells = list_struct(&read_library(&bytes).unwrap().1, "cells", 0);
|
||||
let scan_cells = list_struct(&scan_library(&bytes).unwrap().1, "cells", 0);
|
||||
for refs in [
|
||||
list_struct(&full_cells, "arefs", 0),
|
||||
list_struct(&scan_cells, "refs", 0),
|
||||
] {
|
||||
let column = u64_value(&refs, "xy0", 0);
|
||||
let row = u64_value(&refs, "xy1", 0);
|
||||
assert_eq!((column >> 32) as i32, i32::MAX);
|
||||
assert_eq!(column as i32, -i32::MAX);
|
||||
assert_eq!((row >> 32) as i32, 0);
|
||||
assert_eq!(row as i32, -i32::MAX);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn aref_invalid_counts_and_unrepresentable_pitches_return_errors() {
|
||||
for counts in [[0, 1], [-1, 1], [1, 0], [1, -1]] {
|
||||
let bytes = aref_fixture([0, 0], [10, 0], [0, 10], counts);
|
||||
assert!(read_library(&bytes).is_err());
|
||||
assert!(scan_library(&bytes).is_err());
|
||||
}
|
||||
let bytes = aref_fixture([i32::MIN, 0], [i32::MAX, 0], [i32::MIN, 10], [1, 2]);
|
||||
assert!(read_library(&bytes).is_err());
|
||||
assert!(scan_library(&bytes).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn fractional_aref_pitches_are_rejected_by_all_arrow_readers() {
|
||||
for (column, row, counts) in [
|
||||
([10, 0], [0, 20], [3, 2]),
|
||||
([-10, 0], [0, 20], [3, 2]),
|
||||
([0, 10], [20, 0], [3, 2]),
|
||||
([20, 0], [0, 10], [2, 3]),
|
||||
([20, 0], [-10, 0], [2, 3]),
|
||||
] {
|
||||
let bytes = aref_fixture([0, 0], column, row, counts);
|
||||
let range = [(library_header().len() as u64, bytes.len() as u64 - 4)];
|
||||
for error in [
|
||||
read_library(&bytes).unwrap_err().1,
|
||||
scan_library(&bytes).unwrap_err().1,
|
||||
read_selected_library(&bytes, &range).unwrap_err().1,
|
||||
] {
|
||||
assert!(format!("{error:?}").contains("not an integer database-unit increment"));
|
||||
}
|
||||
}
|
||||
|
||||
let bytes = aref_fixture([0, 0], [10, 0], [0, 20], [3, 2]);
|
||||
let mut array = FFI_ArrowArray::empty();
|
||||
let mut schema = FFI_ArrowSchema::empty();
|
||||
assert_eq!(
|
||||
unsafe { scan_bytes(bytes.as_ptr(), bytes.len(), &mut array, &mut schema) },
|
||||
-1
|
||||
);
|
||||
let range = [library_header().len() as u64, bytes.len() as u64 - 4];
|
||||
assert_eq!(
|
||||
unsafe {
|
||||
read_cells_bytes(
|
||||
bytes.as_ptr(),
|
||||
bytes.len(),
|
||||
range.as_ptr(),
|
||||
1,
|
||||
&mut array,
|
||||
&mut schema,
|
||||
)
|
||||
},
|
||||
-1
|
||||
);
|
||||
let path =
|
||||
std::env::temp_dir().join(format!("pheon-fractional-aref-{}.gds", std::process::id()));
|
||||
struct Cleanup(std::path::PathBuf);
|
||||
impl Drop for Cleanup {
|
||||
fn drop(&mut self) {
|
||||
let _ = std::fs::remove_file(&self.0);
|
||||
}
|
||||
}
|
||||
let _cleanup = Cleanup(path.clone());
|
||||
std::fs::write(&path, &bytes).unwrap();
|
||||
let path = CString::new(path.to_str().unwrap()).unwrap();
|
||||
assert_eq!(
|
||||
unsafe { read_path(path.as_ptr(), &mut array, &mut schema) },
|
||||
-1
|
||||
);
|
||||
let message = unsafe { CStr::from_ptr(last_error_message()) }
|
||||
.to_str()
|
||||
.unwrap();
|
||||
assert!(message.contains("not an integer database-unit increment"));
|
||||
assert!(array.is_released());
|
||||
|
||||
// The object reviewer keeps the exact endpoints, including fractional pitches.
|
||||
let mut bytes = bytes;
|
||||
bytes.truncate(bytes.len() - 4);
|
||||
record(&mut bytes, records::RTAG_BGNSTR, &[0; 24]);
|
||||
record(&mut bytes, records::RTAG_STRNAME, b"leaf");
|
||||
record(&mut bytes, records::RTAG_ENDSTR, &[]);
|
||||
record(&mut bytes, records::RTAG_ENDLIB, &[]);
|
||||
let doc = pheon::review::Document::parse(&bytes).unwrap();
|
||||
assert_eq!(
|
||||
pheon::review::Comparison::between(&doc, &doc).exit_code(),
|
||||
0
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rectangle_detection_handles_extreme_coordinates_and_preserves_other_polygons() {
|
||||
let mut bytes = library_header();
|
||||
record(&mut bytes, records::RTAG_BGNSTR, &[0; 24]);
|
||||
record(&mut bytes, records::RTAG_STRNAME, b"top\0");
|
||||
let wide = [
|
||||
i32::MIN,
|
||||
i32::MIN,
|
||||
i32::MAX,
|
||||
i32::MIN,
|
||||
i32::MAX,
|
||||
i32::MAX,
|
||||
i32::MIN,
|
||||
i32::MAX,
|
||||
i32::MIN,
|
||||
i32::MIN,
|
||||
];
|
||||
let reversed = [
|
||||
i32::MIN,
|
||||
i32::MIN,
|
||||
i32::MIN,
|
||||
i32::MAX,
|
||||
i32::MAX,
|
||||
i32::MAX,
|
||||
i32::MAX,
|
||||
i32::MIN,
|
||||
i32::MIN,
|
||||
i32::MIN,
|
||||
];
|
||||
let diagonal = [0, 0, 10, 10, 0, 10, 10, 0, 0, 0];
|
||||
let degenerate = [0, 0, 0, 0, 10, 0, 10, 0, 0, 0];
|
||||
for points in [&wide, &reversed, &diagonal, °enerate] {
|
||||
record(&mut bytes, records::RTAG_BOUNDARY, &[]);
|
||||
record(&mut bytes, records::RTAG_LAYER, &[0, 1]);
|
||||
record(&mut bytes, records::RTAG_DATATYPE, &[0, 0]);
|
||||
record(&mut bytes, records::RTAG_XY, &xy(points));
|
||||
record(&mut bytes, records::RTAG_ENDEL, &[]);
|
||||
}
|
||||
record(&mut bytes, records::RTAG_ENDSTR, &[]);
|
||||
record(&mut bytes, records::RTAG_ENDLIB, &[]);
|
||||
let full = read_library(&bytes).unwrap().1;
|
||||
let scan = scan_library(&bytes).unwrap().1;
|
||||
assert_eq!(
|
||||
full,
|
||||
read_selected_library(&bytes, &ranges(&scan)).unwrap().1
|
||||
);
|
||||
let cells = list_struct(&full, "cells", 0);
|
||||
let rects = list_struct(&cells, "rect_batches", 0);
|
||||
let values = rects
|
||||
.column_by_name("rects")
|
||||
.unwrap()
|
||||
.as_any()
|
||||
.downcast_ref::<ListArray>()
|
||||
.unwrap()
|
||||
.value(0);
|
||||
let values = values.as_any().downcast_ref::<Int32Array>().unwrap();
|
||||
assert_eq!(
|
||||
values.values().as_ref(),
|
||||
&[
|
||||
i32::MIN,
|
||||
i32::MIN,
|
||||
i32::MAX,
|
||||
i32::MAX,
|
||||
i32::MIN,
|
||||
i32::MIN,
|
||||
i32::MAX,
|
||||
i32::MAX
|
||||
]
|
||||
);
|
||||
let boundaries = list_struct(&cells, "boundary_batches", 0);
|
||||
let values = boundaries
|
||||
.column_by_name("vertices")
|
||||
.unwrap()
|
||||
.as_any()
|
||||
.downcast_ref::<ListArray>()
|
||||
.unwrap()
|
||||
.value(0);
|
||||
let values = values.as_any().downcast_ref::<Int32Array>().unwrap();
|
||||
assert_eq!(
|
||||
values.values().as_ref(),
|
||||
[&diagonal[..8], °enerate[..8]].concat()
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn paths_preserve_missing_explicit_zero_and_negative_widths() {
|
||||
let mut bytes = library_header();
|
||||
record(&mut bytes, records::RTAG_BGNSTR, &[0; 24]);
|
||||
record(&mut bytes, records::RTAG_STRNAME, b"top\0");
|
||||
for width in [None, Some(0_i32), Some(-100)] {
|
||||
record(&mut bytes, records::RTAG_PATH, &[]);
|
||||
record(&mut bytes, records::RTAG_LAYER, &[0, 1]);
|
||||
record(&mut bytes, records::RTAG_DATATYPE, &[0, 0]);
|
||||
if let Some(width) = width {
|
||||
record(&mut bytes, records::RTAG_WIDTH, &width.to_be_bytes());
|
||||
}
|
||||
record(&mut bytes, records::RTAG_XY, &xy(&[0, 0, 10, 10]));
|
||||
record(&mut bytes, records::RTAG_ENDEL, &[]);
|
||||
}
|
||||
record(&mut bytes, records::RTAG_ENDSTR, &[]);
|
||||
record(&mut bytes, records::RTAG_ENDLIB, &[]);
|
||||
let (_, full) = read_library(&bytes).unwrap();
|
||||
let (_, scan) = scan_library(&bytes).unwrap();
|
||||
let (_, selected) = read_selected_library(&bytes, &ranges(&scan)).unwrap();
|
||||
assert_eq!(full, selected);
|
||||
let cells = list_struct(&full, "cells", 0);
|
||||
let paths = list_struct(&cells, "paths", 0);
|
||||
let widths = paths
|
||||
.column_by_name("width")
|
||||
.unwrap()
|
||||
.as_any()
|
||||
.downcast_ref::<Int32Array>()
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
widths.iter().collect::<Vec<_>>(),
|
||||
[None, Some(0), Some(-100)]
|
||||
);
|
||||
}
|
||||
|
||||
fn u64_value(array: &StructArray, name: &str, row: usize) -> u64 {
|
||||
array
|
||||
.column_by_name(name)
|
||||
.unwrap()
|
||||
.as_any()
|
||||
.downcast_ref::<UInt64Array>()
|
||||
.unwrap()
|
||||
.value(row)
|
||||
}
|
||||
|
||||
fn ranges(scan: &StructArray) -> Vec<(u64, u64)> {
|
||||
let cells = list_struct(scan, "cells", 0);
|
||||
(0..cells.len())
|
||||
.map(|i| {
|
||||
(
|
||||
u64_value(&cells, "struct_start_offset", i),
|
||||
u64_value(&cells, "struct_end_offset", i),
|
||||
)
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn scanned_ranges_reproduce_the_full_library_including_offsets() {
|
||||
let bytes = fixture();
|
||||
let (_, full) = read_library(&bytes).unwrap();
|
||||
let (scan_remaining, scan) = scan_library(&bytes).unwrap();
|
||||
assert!(scan_remaining.is_empty());
|
||||
let ranges = ranges(&scan);
|
||||
assert_eq!(ranges.len(), 2);
|
||||
for &(start, end) in &ranges {
|
||||
assert_eq!(&bytes[start as usize..start as usize + 4], &[0, 28, 5, 2]);
|
||||
assert_eq!(&bytes[end as usize - 4..end as usize], &[0, 4, 7, 0]);
|
||||
}
|
||||
let (remaining, selected) = read_selected_library(&bytes, &ranges).unwrap();
|
||||
assert_eq!(remaining, bytes); // Random access leaves the caller's cursor unchanged.
|
||||
assert_eq!(full, selected);
|
||||
let cells = list_struct(&full, "cells", 0);
|
||||
assert_eq!(u64_value(&cells, "file_offset", 0), ranges[0].0 + 28 + 8);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn scan_preserves_reference_transforms_and_skips_geometry() {
|
||||
let bytes = fixture();
|
||||
let (_, scan) = scan_library(&bytes).unwrap();
|
||||
let cells = list_struct(&scan, "cells", 0);
|
||||
let refs = list_struct(&cells, "refs", 0);
|
||||
assert_eq!(refs.len(), 2);
|
||||
assert_eq!(list_struct(&cells, "refs", 1).len(), 0);
|
||||
let target = refs
|
||||
.column_by_name("target")
|
||||
.unwrap()
|
||||
.as_any()
|
||||
.downcast_ref::<UInt32Array>()
|
||||
.unwrap();
|
||||
assert_eq!(target.values().as_ref(), &[1, 1]);
|
||||
assert_eq!(
|
||||
u64_value(&refs, "xy", 0),
|
||||
(3_u64 << 32) | (-4_i32 as u32 as u64)
|
||||
);
|
||||
assert_eq!(u64_value(&refs, "xy0", 0), 0);
|
||||
assert_eq!(u64_value(&refs, "xy1", 0), 0);
|
||||
let counts = refs
|
||||
.column_by_name("counts")
|
||||
.unwrap()
|
||||
.as_any()
|
||||
.downcast_ref::<UInt32Array>()
|
||||
.unwrap();
|
||||
assert_eq!(counts.values().as_ref(), &[(1 << 16) | 1, (2 << 16) | 3]);
|
||||
assert!(
|
||||
refs.column_by_name("invert_y")
|
||||
.unwrap()
|
||||
.as_any()
|
||||
.downcast_ref::<BooleanArray>()
|
||||
.unwrap()
|
||||
.value(1)
|
||||
);
|
||||
assert_eq!(
|
||||
refs.column_by_name("scale")
|
||||
.unwrap()
|
||||
.as_any()
|
||||
.downcast_ref::<Float64Array>()
|
||||
.unwrap()
|
||||
.value(1),
|
||||
2.0
|
||||
);
|
||||
assert_eq!(
|
||||
refs.column_by_name("angle_rad")
|
||||
.unwrap()
|
||||
.as_any()
|
||||
.downcast_ref::<Float64Array>()
|
||||
.unwrap()
|
||||
.value(1),
|
||||
std::f64::consts::FRAC_PI_2
|
||||
);
|
||||
assert_eq!(u64_value(&refs, "xy0", 1), 10_u64 << 32);
|
||||
assert_eq!(u64_value(&refs, "xy1", 1), 10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn selections_support_subsets_reordering_and_empty_results() {
|
||||
let bytes = fixture();
|
||||
let (_, scan) = scan_library(&bytes).unwrap();
|
||||
let ranges = ranges(&scan);
|
||||
let (_, leaf) = read_selected_library(&bytes, &ranges[1..]).unwrap();
|
||||
let leaf_cells = list_struct(&leaf, "cells", 0);
|
||||
assert_eq!(leaf_cells.len(), 1);
|
||||
let leaf_names = leaf
|
||||
.column_by_name("cell_names")
|
||||
.unwrap()
|
||||
.as_any()
|
||||
.downcast_ref::<ListArray>()
|
||||
.unwrap()
|
||||
.value(0);
|
||||
assert_eq!(
|
||||
leaf_names
|
||||
.as_any()
|
||||
.downcast_ref::<StringArray>()
|
||||
.unwrap()
|
||||
.value(0),
|
||||
"leaf"
|
||||
);
|
||||
let (_, reordered) = read_selected_library(&bytes, &[ranges[1], ranges[0]]).unwrap();
|
||||
let reordered_cells = list_struct(&reordered, "cells", 0);
|
||||
assert_eq!(
|
||||
u64_value(&reordered_cells, "file_offset", 0),
|
||||
u64_value(&leaf_cells, "file_offset", 0)
|
||||
);
|
||||
let refs = list_struct(&reordered_cells, "sref_props", 1);
|
||||
assert_eq!(
|
||||
refs.column_by_name("target")
|
||||
.unwrap()
|
||||
.as_any()
|
||||
.downcast_ref::<UInt32Array>()
|
||||
.unwrap()
|
||||
.value(0),
|
||||
0
|
||||
);
|
||||
let (_, empty) = read_selected_library(&bytes, &[]).unwrap();
|
||||
assert_eq!(list_struct(&empty, "cells", 0).len(), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn id_tables_preserve_encounter_order_and_selection_local_ids() {
|
||||
let mut bytes = library_header();
|
||||
for (name, layer, datatype) in [("zeta", 9_i16, 4_i16), ("middle", 2, 8), ("alpha", 9, 4)] {
|
||||
record(&mut bytes, records::RTAG_BGNSTR, &[0; 24]);
|
||||
record(&mut bytes, records::RTAG_STRNAME, name.as_bytes());
|
||||
if name == "zeta" {
|
||||
record(&mut bytes, records::RTAG_SREF, &[]);
|
||||
record(&mut bytes, records::RTAG_SNAME, b"alpha\0");
|
||||
record(&mut bytes, records::RTAG_XY, &xy(&[0, 0]));
|
||||
record(&mut bytes, records::RTAG_ENDEL, &[]);
|
||||
}
|
||||
record(&mut bytes, records::RTAG_BOUNDARY, &[]);
|
||||
record(&mut bytes, records::RTAG_LAYER, &layer.to_be_bytes());
|
||||
record(&mut bytes, records::RTAG_DATATYPE, &datatype.to_be_bytes());
|
||||
record(
|
||||
&mut bytes,
|
||||
records::RTAG_XY,
|
||||
&xy(&[0, 0, 10, 0, 10, 10, 0, 10, 0, 0]),
|
||||
);
|
||||
record(&mut bytes, records::RTAG_ENDEL, &[]);
|
||||
record(&mut bytes, records::RTAG_ENDSTR, &[]);
|
||||
}
|
||||
record(&mut bytes, records::RTAG_ENDLIB, &[]);
|
||||
let (_, scan) = scan_library(&bytes).unwrap();
|
||||
let (_, full) = read_library(&bytes).unwrap();
|
||||
let cell_ranges = ranges(&scan);
|
||||
|
||||
let check = |library: &StructArray, names: &[&str], layers: &[u32], ids: &[u32]| {
|
||||
let values = |name| {
|
||||
library
|
||||
.column_by_name(name)
|
||||
.unwrap()
|
||||
.as_any()
|
||||
.downcast_ref::<ListArray>()
|
||||
.unwrap()
|
||||
.value(0)
|
||||
};
|
||||
let name_values = values("cell_names");
|
||||
assert_eq!(
|
||||
name_values
|
||||
.as_any()
|
||||
.downcast_ref::<StringArray>()
|
||||
.unwrap()
|
||||
.iter()
|
||||
.map(Option::unwrap)
|
||||
.collect::<Vec<_>>(),
|
||||
names
|
||||
);
|
||||
let cells = list_struct(library, "cells", 0);
|
||||
assert_eq!(
|
||||
cells
|
||||
.column_by_name("id")
|
||||
.unwrap()
|
||||
.as_any()
|
||||
.downcast_ref::<UInt32Array>()
|
||||
.unwrap()
|
||||
.values()
|
||||
.as_ref(),
|
||||
ids
|
||||
);
|
||||
if library.column_by_name("layers").is_some() {
|
||||
let layer_values = values("layers");
|
||||
assert_eq!(
|
||||
layer_values
|
||||
.as_any()
|
||||
.downcast_ref::<UInt32Array>()
|
||||
.unwrap()
|
||||
.values()
|
||||
.as_ref(),
|
||||
layers
|
||||
);
|
||||
}
|
||||
};
|
||||
let layer_a = (9 << 16) | 4;
|
||||
let layer_b = (2 << 16) | 8;
|
||||
check(
|
||||
&full,
|
||||
&["zeta", "alpha", "middle"],
|
||||
&[layer_a, layer_b],
|
||||
&[0, 2, 1],
|
||||
);
|
||||
check(&scan, &["zeta", "alpha", "middle"], &[], &[0, 2, 1]);
|
||||
let (_, all_selected) = read_selected_library(&bytes, &cell_ranges).unwrap();
|
||||
assert_eq!(all_selected, full);
|
||||
let (_, subset) = read_selected_library(&bytes, &cell_ranges[1..]).unwrap();
|
||||
check(&subset, &["middle", "alpha"], &[layer_b, layer_a], &[0, 1]);
|
||||
let (_, reversed) =
|
||||
read_selected_library(&bytes, &[cell_ranges[2], cell_ranges[1], cell_ranges[0]]).unwrap();
|
||||
check(
|
||||
&reversed,
|
||||
&["alpha", "middle", "zeta"],
|
||||
&[layer_a, layer_b],
|
||||
&[0, 1, 2],
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn streamed_and_buffered_properties_preserve_duplicates_order_and_empty_lists() {
|
||||
let mut bytes = library_header();
|
||||
record(&mut bytes, records::RTAG_BGNSTR, &[0; 24]);
|
||||
record(&mut bytes, records::RTAG_STRNAME, b"top\0");
|
||||
for (kind, properties) in [
|
||||
(records::RTAG_BOUNDARY, true),
|
||||
(records::RTAG_PATH, true),
|
||||
(records::RTAG_PATH, false),
|
||||
] {
|
||||
record(&mut bytes, kind, &[]);
|
||||
record(&mut bytes, records::RTAG_LAYER, &[0, 1]);
|
||||
record(&mut bytes, records::RTAG_DATATYPE, &[0, 0]);
|
||||
let vertices = if kind == records::RTAG_BOUNDARY {
|
||||
xy(&[0, 0, 10, 0, 10, 10, 0, 10, 0, 0])
|
||||
} else {
|
||||
xy(&[0, 0, 10, 10])
|
||||
};
|
||||
record(&mut bytes, records::RTAG_XY, &vertices);
|
||||
if properties {
|
||||
for (key, value) in [(7_i16, b"first\0".as_slice()), (7, b"second"), (9, b"")] {
|
||||
record(&mut bytes, records::RTAG_PROPATTR, &key.to_be_bytes());
|
||||
record(&mut bytes, records::RTAG_PROPVALUE, value);
|
||||
}
|
||||
}
|
||||
record(&mut bytes, records::RTAG_ENDEL, &[]);
|
||||
}
|
||||
record(&mut bytes, records::RTAG_ENDSTR, &[]);
|
||||
record(&mut bytes, records::RTAG_ENDLIB, &[]);
|
||||
|
||||
let (remaining, full) = read_library(&bytes).unwrap();
|
||||
assert!(remaining.is_empty());
|
||||
let (_, scan) = scan_library(&bytes).unwrap();
|
||||
let (_, selected) = read_selected_library(&bytes, &ranges(&scan)).unwrap();
|
||||
assert_eq!(selected, full);
|
||||
let cells = list_struct(&full, "cells", 0);
|
||||
let boundaries = list_struct(&cells, "boundary_props", 0);
|
||||
let paths = list_struct(&cells, "paths", 0);
|
||||
assert_eq!(boundaries.len(), 1);
|
||||
assert_eq!(paths.len(), 2);
|
||||
for elements in [&boundaries, &paths] {
|
||||
let properties = list_struct(elements, "properties", 0);
|
||||
let keys = properties
|
||||
.column_by_name("key")
|
||||
.unwrap()
|
||||
.as_any()
|
||||
.downcast_ref::<Int16Array>()
|
||||
.unwrap();
|
||||
assert_eq!(keys.values().as_ref(), &[7, 7, 9]);
|
||||
let values = properties
|
||||
.column_by_name("value")
|
||||
.unwrap()
|
||||
.as_any()
|
||||
.downcast_ref::<StringArray>()
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
values.iter().collect::<Vec<_>>(),
|
||||
[Some("first"), Some("second"), Some("")]
|
||||
);
|
||||
}
|
||||
let empty_properties = paths
|
||||
.column_by_name("properties")
|
||||
.unwrap()
|
||||
.as_any()
|
||||
.downcast_ref::<ListArray>()
|
||||
.unwrap();
|
||||
assert!(!empty_properties.is_null(1));
|
||||
assert_eq!(empty_properties.value_length(1), 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn selected_ranges_must_cover_exactly_one_complete_cell() {
|
||||
let bytes = fixture();
|
||||
let (_, scan) = scan_library(&bytes).unwrap();
|
||||
let ranges = ranges(&scan);
|
||||
let (start, end) = ranges[0];
|
||||
for range in [
|
||||
(end, start),
|
||||
(start, u64::MAX),
|
||||
(start, end - 1),
|
||||
(start + 4, end),
|
||||
(start, end + 4),
|
||||
(start, ranges[1].1),
|
||||
] {
|
||||
assert!(
|
||||
read_selected_library(&bytes, &[range]).is_err(),
|
||||
"accepted {range:?}"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ffi_accepts_null_empty_ranges_and_exports_both_schemas() {
|
||||
let bytes = fixture();
|
||||
let mut array = FFI_ArrowArray::empty();
|
||||
let mut schema = FFI_ArrowSchema::empty();
|
||||
assert_eq!(
|
||||
unsafe {
|
||||
read_cells_bytes(
|
||||
bytes.as_ptr(),
|
||||
bytes.len(),
|
||||
ptr::null(),
|
||||
0,
|
||||
&mut array,
|
||||
&mut schema,
|
||||
)
|
||||
},
|
||||
0
|
||||
);
|
||||
let empty = StructArray::from(unsafe { from_ffi(array, &schema) }.unwrap());
|
||||
assert_eq!(list_struct(&empty, "cells", 0).len(), 0);
|
||||
|
||||
let mut array = FFI_ArrowArray::empty();
|
||||
assert_eq!(
|
||||
unsafe { scan_bytes(bytes.as_ptr(), bytes.len(), &mut array, &mut schema) },
|
||||
0
|
||||
);
|
||||
let scan = StructArray::from(unsafe { from_ffi(array, &schema) }.unwrap());
|
||||
let ranges: Vec<u64> = ranges(&scan)
|
||||
.into_iter()
|
||||
.flat_map(|(a, b)| [a, b])
|
||||
.collect();
|
||||
let mut array = FFI_ArrowArray::empty();
|
||||
assert_eq!(
|
||||
unsafe {
|
||||
read_cells_bytes(
|
||||
bytes.as_ptr(),
|
||||
bytes.len(),
|
||||
ranges.as_ptr(),
|
||||
ranges.len() / 2,
|
||||
&mut array,
|
||||
&mut schema,
|
||||
)
|
||||
},
|
||||
0
|
||||
);
|
||||
let selected = StructArray::from(unsafe { from_ffi(array, &schema) }.unwrap());
|
||||
assert_eq!(selected, read_library(&bytes).unwrap().1);
|
||||
assert!(last_error_message().is_null());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn ffi_rejects_null_nonempty_inputs_and_overflowing_range_counts() {
|
||||
let bytes = fixture();
|
||||
let mut array = FFI_ArrowArray::empty();
|
||||
let mut schema = FFI_ArrowSchema::empty();
|
||||
assert_eq!(
|
||||
unsafe { scan_bytes(ptr::null(), 0, &mut array, &mut schema) },
|
||||
-1
|
||||
);
|
||||
assert!(
|
||||
unsafe { CStr::from_ptr(last_error_message()) }
|
||||
.to_str()
|
||||
.unwrap()
|
||||
.contains("scan failed")
|
||||
);
|
||||
assert_eq!(
|
||||
unsafe { scan_bytes(ptr::null(), 1, &mut array, &mut schema) },
|
||||
-1
|
||||
);
|
||||
assert_eq!(
|
||||
unsafe {
|
||||
read_cells_bytes(
|
||||
bytes.as_ptr(),
|
||||
bytes.len(),
|
||||
ptr::null(),
|
||||
1,
|
||||
&mut array,
|
||||
&mut schema,
|
||||
)
|
||||
},
|
||||
-1
|
||||
);
|
||||
assert!(
|
||||
unsafe { CStr::from_ptr(last_error_message()) }
|
||||
.to_str()
|
||||
.unwrap()
|
||||
.contains("ranges pointer was null")
|
||||
);
|
||||
assert_eq!(
|
||||
unsafe {
|
||||
read_cells_bytes(
|
||||
bytes.as_ptr(),
|
||||
bytes.len(),
|
||||
ptr::null(),
|
||||
usize::MAX,
|
||||
&mut array,
|
||||
&mut schema,
|
||||
)
|
||||
},
|
||||
-1
|
||||
);
|
||||
assert!(
|
||||
unsafe { CStr::from_ptr(last_error_message()) }
|
||||
.to_str()
|
||||
.unwrap()
|
||||
.contains("range count is too large")
|
||||
);
|
||||
assert!(array.is_released());
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue