siderust-js 0.1.0

package/qtty-js/qtty/qtty-core/tests/pyo3.rs

@@ -0,0 +1,334 @@
+#![cfg(feature = "pyo3")]
+
+use pyo3::prelude::*;
+use pyo3::types::PyFloat;
+use qtty_core::*;
+
+// Use Length as the test dimension.
+type TestDim = Length;
+
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
+pub enum TestUnit {}
+impl Unit for TestUnit {
+    const RATIO: f64 = 1.0;
+    type Dim = TestDim;
+    const SYMBOL: &'static str = "tu";
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
+pub enum DoubleTestUnit {}
+impl Unit for DoubleTestUnit {
+    const RATIO: f64 = 2.0;
+    type Dim = TestDim;
+    const SYMBOL: &'static str = "dtu";
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
+pub enum HalfTestUnit {}
+impl Unit for HalfTestUnit {
+    const RATIO: f64 = 0.5;
+    type Dim = TestDim;
+    const SYMBOL: &'static str = "htu";
+}
+
+type TU = Quantity<TestUnit>;
+type Dtu = Quantity<DoubleTestUnit>;
+
+/// Helper to initialize Python once for tests
+fn with_py<F, R>(f: F) -> R
+where
+    F: for<'py> FnOnce(Python<'py>) -> R,
+{
+    Python::initialize();
+    Python::attach(f)
+}
+
+#[test]
+fn into_pyobject_basic() {
+    with_py(|py| {
+        let q = TU::new(42.5);
+        let py_obj = q.into_pyobject(py).unwrap();
+        let value: f64 = py_obj.extract().unwrap();
+        assert_eq!(value, 42.5);
+    });
+}
+
+#[test]
+fn into_pyobject_negative() {
+    with_py(|py| {
+        let q = TU::new(-123.456);
+        let py_obj = q.into_pyobject(py).unwrap();
+        let value: f64 = py_obj.extract().unwrap();
+        assert_eq!(value, -123.456);
+    });
+}
+
+#[test]
+fn into_pyobject_zero() {
+    with_py(|py| {
+        let q = TU::new(0.0);
+        let py_obj = q.into_pyobject(py).unwrap();
+        let value: f64 = py_obj.extract().unwrap();
+        assert_eq!(value, 0.0);
+    });
+}
+
+#[test]
+fn into_pyobject_infinity() {
+    with_py(|py| {
+        let q = TU::new(f64::INFINITY);
+        let py_obj = q.into_pyobject(py).unwrap();
+        let value: f64 = py_obj.extract().unwrap();
+        assert!(value.is_infinite() && value.is_sign_positive());
+    });
+}
+
+#[test]
+fn into_pyobject_neg_infinity() {
+    with_py(|py| {
+        let q = TU::new(f64::NEG_INFINITY);
+        let py_obj = q.into_pyobject(py).unwrap();
+        let value: f64 = py_obj.extract().unwrap();
+        assert!(value.is_infinite() && value.is_sign_negative());
+    });
+}
+
+#[test]
+fn into_pyobject_nan() {
+    with_py(|py| {
+        let q = TU::new(f64::NAN);
+        let py_obj = q.into_pyobject(py).unwrap();
+        let value: f64 = py_obj.extract().unwrap();
+        assert!(value.is_nan());
+    });
+}
+
+#[test]
+fn into_pyobject_very_large() {
+    with_py(|py| {
+        let q = TU::new(1e100);
+        let py_obj = q.into_pyobject(py).unwrap();
+        let value: f64 = py_obj.extract().unwrap();
+        assert_eq!(value, 1e100);
+    });
+}
+
+#[test]
+fn into_pyobject_very_small() {
+    with_py(|py| {
+        let q = TU::new(1e-100);
+        let py_obj = q.into_pyobject(py).unwrap();
+        let value: f64 = py_obj.extract().unwrap();
+        assert_eq!(value, 1e-100);
+    });
+}
+
+#[test]
+fn from_pyobject_basic() {
+    with_py(|py| {
+        let py_float = PyFloat::new(py, 42.5);
+        let q: TU = py_float.extract().unwrap();
+        assert_eq!(q.value(), 42.5);
+    });
+}
+
+#[test]
+fn from_pyobject_negative() {
+    with_py(|py| {
+        let py_float = PyFloat::new(py, -123.456);
+        let q: TU = py_float.extract().unwrap();
+        assert_eq!(q.value(), -123.456);
+    });
+}
+
+#[test]
+fn from_pyobject_zero() {
+    with_py(|py| {
+        let py_float = PyFloat::new(py, 0.0);
+        let q: TU = py_float.extract().unwrap();
+        assert_eq!(q.value(), 0.0);
+    });
+}
+
+#[test]
+fn from_pyobject_infinity() {
+    with_py(|py| {
+        let py_float = PyFloat::new(py, f64::INFINITY);
+        let q: TU = py_float.extract().unwrap();
+        assert!(q.value().is_infinite() && q.value().is_sign_positive());
+    });
+}
+
+#[test]
+fn from_pyobject_neg_infinity() {
+    with_py(|py| {
+        let py_float = PyFloat::new(py, f64::NEG_INFINITY);
+        let q: TU = py_float.extract().unwrap();
+        assert!(q.value().is_infinite() && q.value().is_sign_negative());
+    });
+}
+
+#[test]
+fn from_pyobject_nan() {
+    with_py(|py| {
+        let py_float = PyFloat::new(py, f64::NAN);
+        let q: TU = py_float.extract().unwrap();
+        assert!(q.value().is_nan());
+    });
+}
+
+#[test]
+fn from_pyobject_very_large() {
+    with_py(|py| {
+        let py_float = PyFloat::new(py, 1e100);
+        let q: TU = py_float.extract().unwrap();
+        assert_eq!(q.value(), 1e100);
+    });
+}
+
+#[test]
+fn from_pyobject_very_small() {
+    with_py(|py| {
+        let py_float = PyFloat::new(py, 1e-100);
+        let q: TU = py_float.extract().unwrap();
+        assert_eq!(q.value(), 1e-100);
+    });
+}
+
+#[test]
+fn roundtrip_basic() {
+    with_py(|py| {
+        let original = TU::new(123.456);
+        let py_obj = original.into_pyobject(py).unwrap();
+        let restored: TU = py_obj.extract().unwrap();
+        assert!((restored.value() - original.value()).abs() < 1e-12);
+    });
+}
+
+#[test]
+fn roundtrip_negative() {
+    with_py(|py| {
+        let original = TU::new(-987.654);
+        let py_obj = original.into_pyobject(py).unwrap();
+        let restored: TU = py_obj.extract().unwrap();
+        assert!((restored.value() - original.value()).abs() < 1e-12);
+    });
+}
+
+#[test]
+fn roundtrip_zero() {
+    with_py(|py| {
+        let original = TU::new(0.0);
+        let py_obj = original.into_pyobject(py).unwrap();
+        let restored: TU = py_obj.extract().unwrap();
+        assert_eq!(restored.value(), original.value());
+    });
+}
+
+#[test]
+fn roundtrip_very_large() {
+    with_py(|py| {
+        let original = TU::new(1e100);
+        let py_obj = original.into_pyobject(py).unwrap();
+        let restored: TU = py_obj.extract().unwrap();
+        assert_eq!(restored.value(), original.value());
+    });
+}
+
+#[test]
+fn roundtrip_very_small() {
+    with_py(|py| {
+        let original = TU::new(1e-100);
+        let py_obj = original.into_pyobject(py).unwrap();
+        let restored: TU = py_obj.extract().unwrap();
+        assert_eq!(restored.value(), original.value());
+    });
+}
+
+#[test]
+fn roundtrip_different_unit_types() {
+    with_py(|py| {
+        // Test with DoubleTestUnit
+        let original_dtu = Dtu::new(42.5);
+        let py_obj = original_dtu.into_pyobject(py).unwrap();
+        let restored_dtu: Dtu = py_obj.extract().unwrap();
+        assert!((restored_dtu.value() - original_dtu.value()).abs() < 1e-12);
+
+        // Test with HalfTestUnit
+        let original_htu = Quantity::<HalfTestUnit>::new(99.9);
+        let py_obj = original_htu.into_pyobject(py).unwrap();
+        let restored_htu: Quantity<HalfTestUnit> = py_obj.extract().unwrap();
+        assert!((restored_htu.value() - original_htu.value()).abs() < 1e-12);
+    });
+}
+
+#[test]
+fn roundtrip_preserves_precision() {
+    with_py(|py| {
+        // Test that precision is preserved through conversion
+        let original = TU::new(core::f64::consts::PI);
+        let py_obj = original.into_pyobject(py).unwrap();
+        let restored: TU = py_obj.extract().unwrap();
+        assert_eq!(restored.value(), original.value());
+    });
+}
+
+#[test]
+fn into_pyobject_returns_pyfloat() {
+    with_py(|py| {
+        let q = TU::new(42.5);
+        let py_obj = q.into_pyobject(py).unwrap();
+        // Verify it's actually a PyFloat
+        assert!(py_obj.is_instance_of::<PyFloat>());
+    });
+}
+
+#[test]
+fn from_pyobject_from_int() {
+    with_py(|py| {
+        // Python integers can be converted to f64
+        let py_int = py.eval(c"42", None, None).unwrap();
+        let q: TU = py_int.extract().unwrap();
+        assert_eq!(q.value(), 42.0);
+    });
+}
+
+#[test]
+fn from_pyobject_from_calculation() {
+    with_py(|py| {
+        // Extract from a Python calculation result
+        let py_result = py.eval(c"2.5 * 10.0", None, None).unwrap();
+        let q: TU = py_result.extract().unwrap();
+        assert_eq!(q.value(), 25.0);
+    });
+}
+
+#[test]
+fn from_pyobject_error_on_string() {
+    with_py(|py| {
+        // Should fail to extract from a string
+        let py_str = py.eval(c"'not a number'", None, None).unwrap();
+        let result: PyResult<TU> = py_str.extract();
+        assert!(result.is_err());
+    });
+}
+
+#[test]
+fn from_pyobject_error_on_none() {
+    with_py(|py| {
+        // Should fail to extract from None
+        let py_none = py.eval(c"None", None, None).unwrap();
+        let result: PyResult<TU> = py_none.extract();
+        assert!(result.is_err());
+    });
+}
+
+#[test]
+fn from_pyobject_error_on_list() {
+    with_py(|py| {
+        // Should fail to extract from a list
+        let py_list = py.eval(c"[1, 2, 3]", None, None).unwrap();
+        let result: PyResult<TU> = py_list.extract();
+        assert!(result.is_err());
+    });
+}

package/qtty-js/qtty/qtty-core/tests/quantity_f32.rs

@@ -0,0 +1,276 @@
+//! Tests for Quantity<U, f32> methods (coverage for quantity.rs f32 paths).
+
+use qtty_core::*;
+
+// Use Length as the test dimension.
+type TestDim = Length;
+
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
+pub enum TestUnit {}
+impl Unit for TestUnit {
+    const RATIO: f64 = 1.0;
+    type Dim = TestDim;
+    const SYMBOL: &'static str = "tu";
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, PartialOrd)]
+pub enum DoubleTestUnit {}
+impl Unit for DoubleTestUnit {
+    const RATIO: f64 = 2.0;
+    type Dim = TestDim;
+    const SYMBOL: &'static str = "dtu";
+}
+
+type TU32 = Quantity<TestUnit, f32>;
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Const methods for f32
+// ─────────────────────────────────────────────────────────────────────────────
+
+#[test]
+fn f32_const_add() {
+    let a = TU32::new(3.0);
+    let b = TU32::new(7.0);
+    assert_eq!(a.const_add(b).value(), 10.0_f32);
+}
+
+#[test]
+fn f32_const_sub() {
+    let a = TU32::new(10.0);
+    let b = TU32::new(3.0);
+    assert_eq!(a.const_sub(b).value(), 7.0_f32);
+}
+
+#[test]
+fn f32_const_mul() {
+    let a = TU32::new(4.0);
+    assert_eq!(a.const_mul(5.0).value(), 20.0_f32);
+}
+
+#[test]
+fn f32_const_div() {
+    let a = TU32::new(20.0);
+    assert_eq!(a.const_div(4.0).value(), 5.0_f32);
+}
+
+#[test]
+fn f32_to_const() {
+    let q = TU32::new(10.0);
+    let converted: Quantity<DoubleTestUnit, f32> = q.to_const();
+    assert!((converted.value() - 5.0).abs() < 1e-6);
+}
+
+#[test]
+fn f32_min_const() {
+    let a = TU32::new(3.0);
+    let b = TU32::new(7.0);
+    assert_eq!(a.min_const(b).value(), 3.0_f32);
+    assert_eq!(b.min_const(a).value(), 3.0_f32);
+}
+
+#[test]
+fn f32_max_const() {
+    let a = TU32::new(3.0);
+    let b = TU32::new(7.0);
+    assert_eq!(a.max_const(b).value(), 7.0_f32);
+    assert_eq!(b.max_const(a).value(), 7.0_f32);
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Real-specific Quantity methods for f32
+// ─────────────────────────────────────────────────────────────────────────────
+
+#[test]
+fn f32_quantity_nan_constant() {
+    assert!(TU32::NAN.value().is_nan());
+}
+
+#[test]
+fn f32_quantity_infinity() {
+    assert!(TU32::INFINITY.value().is_infinite());
+    assert!(TU32::NEG_INFINITY.value().is_infinite());
+}
+
+#[test]
+fn f32_quantity_is_nan() {
+    assert!(TU32::NAN.is_nan());
+    assert!(!TU32::new(42.0).is_nan());
+}
+
+#[test]
+fn f32_quantity_is_infinite() {
+    assert!(TU32::INFINITY.is_infinite());
+    assert!(!TU32::new(42.0).is_infinite());
+}
+
+#[test]
+fn f32_quantity_is_finite() {
+    assert!(TU32::new(42.0).is_finite());
+    assert!(!TU32::INFINITY.is_finite());
+    assert!(!TU32::NAN.is_finite());
+}
+
+#[test]
+fn f32_quantity_signum() {
+    assert_eq!(TU32::new(42.0).signum(), 1.0_f32);
+    assert_eq!(TU32::new(-42.0).signum(), -1.0_f32);
+}
+
+#[test]
+fn f32_quantity_sqrt() {
+    let q = TU32::new(16.0);
+    assert!((q.sqrt().value() - 4.0).abs() < 1e-6);
+}
+
+#[test]
+fn f32_quantity_ceil() {
+    assert_eq!(TU32::new(3.2).ceil().value(), 4.0_f32);
+    assert_eq!(TU32::new(-3.2).ceil().value(), -3.0_f32);
+    assert_eq!(TU32::new(5.0).ceil().value(), 5.0_f32);
+}
+
+#[test]
+fn f32_quantity_cast() {
+    let q = TU32::new(42.5);
+    let q_f64: Quantity<TestUnit, f64> = q.cast();
+    assert!((q_f64.value() - 42.5).abs() < 1e-6);
+}
+
+#[test]
+fn f32_quantity_to() {
+    let q = TU32::new(10.0);
+    let converted: Quantity<DoubleTestUnit, f32> = q.to();
+    assert!((converted.value() - 5.0).abs() < 1e-6);
+}
+
+#[test]
+fn f32_quantity_abs() {
+    assert_eq!(TU32::new(-5.0).abs().value(), 5.0_f32);
+}
+
+#[test]
+fn f32_quantity_min_max() {
+    let a = TU32::new(3.0);
+    let b = TU32::new(7.0);
+    assert_eq!(a.min(b).value(), 3.0_f32);
+    assert_eq!(a.max(b).value(), 7.0_f32);
+    assert_eq!(a.mean(b).value(), 5.0_f32);
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Commutative multiplication: f32 * Quantity
+// ─────────────────────────────────────────────────────────────────────────────
+
+#[test]
+fn f32_commutative_mul() {
+    let q = TU32::new(5.0);
+    assert_eq!((3.0_f32 * q).value(), 15.0_f32);
+    assert_eq!((q * 3.0_f32).value(), 15.0_f32);
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Operators: Add/Sub/Neg/Div/Rem
+// ─────────────────────────────────────────────────────────────────────────────
+
+#[test]
+fn f32_quantity_add_sub() {
+    let a = TU32::new(10.0);
+    let b = TU32::new(3.0);
+    assert_eq!((a + b).value(), 13.0_f32);
+    assert_eq!((a - b).value(), 7.0_f32);
+}
+
+#[test]
+fn f32_quantity_neg() {
+    assert_eq!((-TU32::new(5.0)).value(), -5.0_f32);
+}
+
+#[test]
+fn f32_quantity_div_scalar() {
+    assert_eq!((TU32::new(15.0) / 3.0_f32).value(), 5.0_f32);
+}
+
+#[test]
+fn f32_quantity_rem() {
+    assert_eq!((TU32::new(10.0) % 3.0_f32).value(), 1.0_f32);
+}
+
+#[test]
+fn f32_quantity_partial_eq() {
+    let q = TU32::new(42.0);
+    assert!(q == 42.0_f32);
+}
+
+#[test]
+fn f32_quantity_from() {
+    let q: TU32 = 42.0_f32.into();
+    assert_eq!(q.value(), 42.0_f32);
+}
+
+#[test]
+fn f32_quantity_zero_one() {
+    assert_eq!(TU32::zero().value(), 0.0_f32);
+    assert_eq!(TU32::one().value(), 1.0_f32);
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Division producing Per type with f32
+// ─────────────────────────────────────────────────────────────────────────────
+
+#[test]
+fn f32_division_creates_per() {
+    let num = TU32::new(100.0);
+    let den = Quantity::<DoubleTestUnit, f32>::new(20.0);
+    let ratio: Quantity<Per<TestUnit, DoubleTestUnit>, f32> = num / den;
+    assert!((ratio.value() - 5.0).abs() < 1e-6);
+}
+
+#[test]
+fn f32_per_mul_recovers_numerator() {
+    let rate: Quantity<Per<TestUnit, DoubleTestUnit>, f32> = Quantity::new(5.0);
+    let den = Quantity::<DoubleTestUnit, f32>::new(4.0);
+    let result: TU32 = (rate * den).to();
+    assert!((result.value() - 20.0).abs() < 1e-6);
+}
+
+#[test]
+fn f32_simplify() {
+    let ratio: Quantity<Per<TestUnit, TestUnit>, f32> = Quantity::new(2.5);
+    let unitless: Quantity<Unitless, f32> = ratio.simplify();
+    assert!((unitless.value() - 2.5).abs() < 1e-6);
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Assign ops
+// ─────────────────────────────────────────────────────────────────────────────
+
+#[test]
+fn f32_add_assign() {
+    let mut q = TU32::new(5.0);
+    q += TU32::new(3.0);
+    assert_eq!(q.value(), 8.0_f32);
+}
+
+#[test]
+fn f32_sub_assign() {
+    let mut q = TU32::new(10.0);
+    q -= TU32::new(3.0);
+    assert_eq!(q.value(), 7.0_f32);
+}
+
+#[test]
+fn f32_div_assign() {
+    let mut q = TU32::new(20.0);
+    q /= 4.0_f32;
+    assert_eq!(q.value(), 5.0_f32);
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// value_ref
+// ─────────────────────────────────────────────────────────────────────────────
+
+#[test]
+fn f32_value_ref() {
+    let q = TU32::new(42.5);
+    assert_eq!(*q.value_ref(), 42.5_f32);
+}