From 6ee055c38b13e45f68347468bba6a42b7db6eb2d Mon Sep 17 00:00:00 2001 From: Erick Ahmed Date: Thu, 13 Nov 2025 00:02:09 +0100 Subject: [PATCH] test: separate tests into debug and API level tests --- src/ffi/point.rs | 57 +++++++++++++++++++----- tests/point_test.rs | 106 +++++++++++++++++++++++++++++++++++++++++++- 2 files changed, 152 insertions(+), 11 deletions(-) diff --git a/src/ffi/point.rs b/src/ffi/point.rs index 0d5edca..94afd7b 100644 --- a/src/ffi/point.rs +++ b/src/ffi/point.rs @@ -90,25 +90,62 @@ pub use ffi_point::Point; #[cfg(test)] mod tests { use super::*; + use std::os::raw::c_double; #[test] - fn point_creation() { - let p = Point::new(1.0, 2.0, -3.0).expect("Failed to create point"); + fn point_debug_precision() { + let p = Point::new(1.123456789, 2.987654321, -3.555555555).expect("Failed to create point"); + let debug_str = format!("{:?}", p); + let coords = p.coordinates(); - assert_eq!(coords, (1.0, 2.0, -3.0)); + assert!(debug_str.contains(&coords.0.to_string())); + assert!(debug_str.contains(&coords.1.to_string())); + assert!(debug_str.contains(&coords.2.to_string())); } #[test] - fn point_query() { - let p = Point::new(5.5, 3.15, -0.001).expect("Failed to create point"); + fn point_null_pointer_safety() { + let result = Point::new(1.0, 2.0, 3.0); + assert!(result.is_ok()); + + let p = result.unwrap(); let coords = p.coordinates(); - assert_eq!(coords, (5.5, 3.15, -0.001)); + + assert_eq!(coords, (1.0, 2.0, 3.0)); } #[test] - fn point_deletion() { - let p = Point::new(1.0, 2.0, 3.0).expect("Failed to create point"); - let result = p.delete(); - assert!(result.is_ok(), "Deletion should succeed for valid point"); + fn point_drop_impl_safety() { + { + let p = Point::new(1.0, 2.0, 3.0).expect("Failed to create point"); + // p goes out of scope here and should be dropped + } + let p2 = Point::new(4.0, 5.0, 6.0).expect("Failed to create point after drop"); + assert_eq!(p2.coordinates(), (4.0, 5.0, 6.0)); + } + + #[test] + fn point_ffi_repr_c() { + use std::mem; + + // PointShape should be repr(C) and zero-sized in Rust + assert_eq!(mem::size_of::(), 0); + + // c_double should match f64 + assert_eq!(mem::size_of::(), mem::size_of::()); + assert_eq!(mem::align_of::(), mem::align_of::()); + } + + #[test] + fn point_coordinates_after_multiple_uses() { + let p = Point::new(1.1, 2.2, 3.3).expect("Failed to create point"); + + let _coords1 = p.coordinates(); + let _debug1 = format!("{:?}", p); + let _coords2 = p.coordinates(); + let _debug2 = format!("{:?}", p); + let final_coords = p.coordinates(); + + assert_eq!(final_coords, (1.1, 2.2, 3.3)); } } diff --git a/tests/point_test.rs b/tests/point_test.rs index 49a33e5..e11c9eb 100644 --- a/tests/point_test.rs +++ b/tests/point_test.rs @@ -5,4 +5,108 @@ use arc_core::ffi::point::Point; -#[test] +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn point_creation() { + let p = Point::new(1.0, 2.0, -3.0).expect("Failed to create point"); + let coords = p.coordinates(); + assert_eq!(coords, (1.0, 2.0, -3.0)); + } + + #[test] + fn point_query() { + let p = Point::new(5.5, 3.15, -0.001).expect("Failed to create point"); + let coords = p.coordinates(); + assert_eq!(coords, (5.5, 3.15, -0.001)); + } + + #[test] + fn point_deletion() { + let p = Point::new(1.0, 2.0, 3.0).expect("Failed to create point"); + let result = p.delete(); + assert!(result.is_ok(), "Deletion should succeed for valid point"); + } + + #[test] + fn point_creation_extreme_values() { + let cases = [ + (f64::MAX, f64::MIN, 0.0), + (0.0, 0.0, 0.0), + (-f64::MAX, -f64::MIN, f64::EPSILON), + ]; + + for (x, y, z) in cases { + let p = Point::new(x, y, z).expect("Failed to create point with extreme values"); + let coords = p.coordinates(); + assert_eq!(coords, (x, y, z)); + p.delete().expect("Failed to delete point"); + } + } + + #[test] + fn point_coordinates_immutability() { + let p = Point::new(1.5, 2.5, 3.5).expect("Failed to create point"); + + let coords1 = p.coordinates(); + let coords2 = p.coordinates(); + let coords3 = p.coordinates(); + + assert_eq!(coords1, coords2); + assert_eq!(coords2, coords3); + assert_eq!(coords1, (1.5, 2.5, 3.5)); + } + + #[test] + fn point_automatic_cleanup_on_drop() { + let coords = { + let p = Point::new(7.0, 8.0, 9.0).expect("Failed to create point"); + p.coordinates() + }; + + assert_eq!(coords, (7.0, 8.0, 9.0)); + + // Verify we can still create points after automatic cleanup + let p2 = Point::new(10.0, 11.0, 12.0).expect("Failed to create point after drop"); + assert_eq!(p2.coordinates(), (10.0, 11.0, 12.0)); + } + + #[test] + fn point_multiple_instances_independent() { + let p1 = Point::new(1.0, 1.0, 1.0).expect("Failed to create point 1"); + let p2 = Point::new(2.0, 2.0, 2.0).expect("Failed to create point 2"); + let p3 = Point::new(3.0, 3.0, 3.0).expect("Failed to create point 3"); + + assert_eq!(p1.coordinates(), (1.0, 1.0, 1.0)); + assert_eq!(p2.coordinates(), (2.0, 2.0, 2.0)); + assert_eq!(p3.coordinates(), (3.0, 3.0, 3.0)); + + p2.delete().expect("Failed to delete p2"); + p1.delete().expect("Failed to delete p1"); + p3.delete().expect("Failed to delete p3"); + } + + #[test] + fn point_debug_format() { + let p = Point::new(1.1, 2.2, 3.3).expect("Failed to create point"); + let debug_output = format!("{:?}", p); + + assert!(debug_output.contains("Point")); + assert!(debug_output.contains("1.1")); + assert!(debug_output.contains("2.2")); + assert!(debug_output.contains("3.3")); + } + + #[test] + fn point_rapid_creation_deletion_cycle_stress_test() { + for i in 0..100 { + let p = Point::new(i as f64, i as f64, i as f64) + .expect(&format!("Failed to create point in iteration {}", i)); + assert_eq!(p.coordinates(), (i as f64, i as f64, i as f64)); + p.delete() + .expect(&format!("Failed to delete point in iteration {}", i)); + } + } +}