siderust-js 0.1.0

package/qtty-js/qtty/qtty-ffi/src/lib.rs

@@ -0,0 +1,229 @@
+//! C-compatible FFI bindings for `qtty` physical quantities and unit conversions.
+//!
+//! `qtty-ffi` provides a stable C ABI for `qtty`, enabling interoperability with C/C++ code
+//! and other languages with C FFI support. It also provides helper types and macros for
+//! downstream Rust crates that need to expose their own FFI APIs using `qtty` quantities.
+//!
+//! # Features
+//!
+//! - **ABI-stable types**: `#[repr(C)]` and `#[repr(u32)]` types safe for FFI
+//! - **Unit registry**: Mapping between FFI unit IDs and conversion factors
+//! - **C API**: `extern "C"` functions for quantity construction and conversion
+//! - **Rust helpers**: Macros and trait implementations for downstream integration
+//!
+//! # Quick Start (C/C++)
+//!
+//! Include the generated header and link against the library:
+//!
+//! ```c
+//! #include "qtty_ffi.h"
+//!
+//! // Create a quantity
+//! QttyQuantity meters;
+//! qtty_quantity_make(1000.0, UnitId_Meter, &meters);
+//!
+//! // Convert to kilometers
+//! QttyQuantity kilometers;
+//! int32_t status = qtty_quantity_convert(meters, UnitId_Kilometer, &kilometers);
+//! if (status == QTTY_OK) {
+//!     // kilometers.value == 1.0
+//! }
+//! ```
+//!
+//! # Quick Start (Rust)
+//!
+//! Use the helper traits and macros for seamless conversion:
+//!
+//! ```rust
+//! use qtty::length::{Meters, Kilometers};
+//! use qtty_ffi::{QttyQuantity, UnitId};
+//!
+//! // Convert Rust type to FFI
+//! let meters = Meters::new(1000.0);
+//! let ffi_qty: QttyQuantity = meters.into();
+//!
+//! // Convert FFI back to Rust type (with automatic unit conversion)
+//! let km: Kilometers = ffi_qty.try_into().unwrap();
+//! assert!((km.value() - 1.0).abs() < 1e-12);
+//! ```
+//!
+//! # ABI Stability
+//!
+//! The following are part of the ABI contract and will never change:
+//!
+//! - [`UnitId`] discriminant values (existing variants)
+//! - [`DimensionId`] discriminant values (existing variants)
+//! - [`QttyQuantity`] memory layout
+//! - Status code values ([`QTTY_OK`], [`QTTY_ERR_UNKNOWN_UNIT`], etc.)
+//! - Function signatures of exported `extern "C"` functions
+//!
+//! New variants may be added to enums (with new discriminant values), and new functions
+//! may be added, but existing items will remain stable.
+//!
+//! # Supported Units (v1)
+//!
+//! ## Length
+//! - [`UnitId::Meter`] - SI base unit
+//! - [`UnitId::Kilometer`] - 1000 meters
+//!
+//! ## Time
+//! - [`UnitId::Second`] - SI base unit
+//! - [`UnitId::Minute`] - 60 seconds
+//! - [`UnitId::Hour`] - 3600 seconds
+//! - [`UnitId::Day`] - 86400 seconds
+//!
+//! ## Angle
+//! - [`UnitId::Radian`] - SI unit
+//! - [`UnitId::Degree`] - π/180 radians
+//!
+//! # Error Handling
+//!
+//! All FFI functions return status codes:
+//!
+//! - [`QTTY_OK`] (0): Success
+//! - [`QTTY_ERR_UNKNOWN_UNIT`] (-1): Invalid unit ID
+//! - [`QTTY_ERR_INCOMPATIBLE_DIM`] (-2): Dimension mismatch
+//! - [`QTTY_ERR_NULL_OUT`] (-3): Null output pointer
+//! - [`QTTY_ERR_INVALID_VALUE`] (-4): Invalid value (reserved)
+//! - [`QTTY_ERR_BUFFER_TOO_SMALL`] (-5): Output buffer too small
+//!
+//! Format flags for [`qtty_quantity_format`]:
+//!
+//! - [`QTTY_FMT_DEFAULT`] (0): decimal notation
+//! - [`QTTY_FMT_LOWER_EXP`] (1): scientific notation (lowercase `e`)
+//! - [`QTTY_FMT_UPPER_EXP`] (2): scientific notation (uppercase `E`)
+//!
+//! # Thread Safety
+//!
+//! All functions are thread-safe. The library contains no global mutable state.
+
+#![deny(missing_docs)]
+// PyO3 generated code contains unsafe operations, so we can't enforce this when pyo3 feature is enabled
+#![cfg_attr(not(feature = "pyo3"), deny(unsafe_op_in_unsafe_fn))]
+
+// Core modules
+mod ffi;
+pub mod helpers;
+#[macro_use]
+pub mod macros;
+pub mod registry;
+mod types;
+
+// Re-export FFI functions
+pub use ffi::{
+    qtty_derived_convert, qtty_derived_from_json, qtty_derived_make, qtty_derived_to_json,
+    qtty_ffi_version, qtty_quantity_convert, qtty_quantity_convert_value, qtty_quantity_format,
+    qtty_quantity_from_json, qtty_quantity_from_json_value, qtty_quantity_make,
+    qtty_quantity_to_json, qtty_quantity_to_json_value, qtty_string_free, qtty_unit_dimension,
+    qtty_unit_is_valid, qtty_unit_name, qtty_units_compatible,
+};
+
+// Re-export types
+pub use types::{
+    DimensionId, QttyDerivedQuantity, QttyQuantity, UnitId, QTTY_ERR_BUFFER_TOO_SMALL,
+    QTTY_ERR_INCOMPATIBLE_DIM, QTTY_ERR_INVALID_VALUE, QTTY_ERR_NULL_OUT, QTTY_ERR_UNKNOWN_UNIT,
+    QTTY_FMT_DEFAULT, QTTY_FMT_LOWER_EXP, QTTY_FMT_UPPER_EXP, QTTY_OK,
+};
+
+// The impl_unit_ffi! macro is automatically exported at crate root by #[macro_export]
+
+// Re-export helper functions
+pub use helpers::{
+    days_into_ffi, degrees_into_ffi, hours_into_ffi, kilometers_into_ffi, meters_into_ffi,
+    minutes_into_ffi, radians_into_ffi, seconds_into_ffi, try_into_days, try_into_degrees,
+    try_into_hours, try_into_kilometers, try_into_meters, try_into_minutes, try_into_radians,
+    try_into_seconds,
+};
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use core::mem::{align_of, size_of};
+
+    /// Test that QttyQuantity has the expected size and alignment for FFI.
+    #[test]
+    fn test_qtty_quantity_layout() {
+        // QttyQuantity should be:
+        // - f64 (8 bytes) + UnitId (4 bytes) + padding (4 bytes) = 16 bytes
+        // - Aligned to 8 bytes (alignment of f64)
+        assert_eq!(size_of::<QttyQuantity>(), 16);
+        assert_eq!(align_of::<QttyQuantity>(), 8);
+    }
+
+    /// Test that UnitId has the expected size.
+    #[test]
+    fn test_unit_id_layout() {
+        assert_eq!(size_of::<UnitId>(), 4);
+        assert_eq!(align_of::<UnitId>(), 4);
+    }
+
+    /// Test that DimensionId has the expected size.
+    #[test]
+    fn test_dimension_id_layout() {
+        assert_eq!(size_of::<DimensionId>(), 4);
+        assert_eq!(align_of::<DimensionId>(), 4);
+    }
+
+    /// Test known conversion: 1000 meters → 1 kilometer
+    #[test]
+    fn test_known_conversion_meters_to_kilometers() {
+        let mut out = QttyQuantity::default();
+        let src = QttyQuantity::new(1000.0, UnitId::Meter);
+
+        let status = unsafe { qtty_quantity_convert(src, UnitId::Kilometer, &mut out) };
+
+        assert_eq!(status, QTTY_OK);
+        assert!((out.value - 1.0).abs() < 1e-12);
+        assert_eq!(out.unit, UnitId::Kilometer);
+    }
+
+    /// Test known conversion: 3600 seconds → 1 hour
+    #[test]
+    fn test_known_conversion_seconds_to_hours() {
+        let mut out = QttyQuantity::default();
+        let src = QttyQuantity::new(3600.0, UnitId::Second);
+
+        let status = unsafe { qtty_quantity_convert(src, UnitId::Hour, &mut out) };
+
+        assert_eq!(status, QTTY_OK);
+        assert!((out.value - 1.0).abs() < 1e-12);
+        assert_eq!(out.unit, UnitId::Hour);
+    }
+
+    /// Test known conversion: 180 degrees → π radians
+    #[test]
+    fn test_known_conversion_degrees_to_radians() {
+        use core::f64::consts::PI;
+
+        let mut out = QttyQuantity::default();
+        let src = QttyQuantity::new(180.0, UnitId::Degree);
+
+        let status = unsafe { qtty_quantity_convert(src, UnitId::Radian, &mut out) };
+
+        assert_eq!(status, QTTY_OK);
+        assert!((out.value - PI).abs() < 1e-12);
+        assert_eq!(out.unit, UnitId::Radian);
+    }
+
+    /// Test incompatible conversion: meters → seconds fails
+    #[test]
+    fn test_incompatible_conversion_fails() {
+        let mut out = QttyQuantity::default();
+        let src = QttyQuantity::new(100.0, UnitId::Meter);
+
+        let status = unsafe { qtty_quantity_convert(src, UnitId::Second, &mut out) };
+
+        assert_eq!(status, QTTY_ERR_INCOMPATIBLE_DIM);
+    }
+
+    /// Test null output pointer handling
+    #[test]
+    fn test_null_out_pointer() {
+        let src = QttyQuantity::new(100.0, UnitId::Meter);
+
+        let status =
+            unsafe { qtty_quantity_convert(src, UnitId::Kilometer, core::ptr::null_mut()) };
+
+        assert_eq!(status, QTTY_ERR_NULL_OUT);
+    }
+}

package/qtty-js/qtty/qtty-ffi/src/macros.rs

@@ -0,0 +1,121 @@
+//! Macros for implementing FFI conversions for qtty unit types.
+//!
+//! This module provides macros that make it easy to implement `From` and `TryFrom`
+//! conversions between `qtty` unit types and [`QttyQuantity`], as well as code generation
+//! macros for defining all FFI units in one place.
+//!
+//! # Example
+//!
+//! The macro is intended to be used in crates that own the types being converted.
+//! Since `qtty-ffi` already implements these for the standard `qtty` types, you
+//! typically only need this for custom wrapper types.
+//!
+//! ```rust,ignore
+//! use qtty_ffi::{impl_unit_ffi, QttyQuantity, UnitId};
+//! use qtty::length::Meters;
+//!
+//! // This would work in your own crate that defines MyMeters:
+//! impl_unit_ffi!(MyMeters, UnitId::Meter);
+//!
+//! // Then you can convert between MyMeters and QttyQuantity
+//! let meters = MyMeters::new(100.0);
+//! let quantity: QttyQuantity = meters.into();
+//! ```
+
+/// Internal helper macro for generating unit match arms in `UnitId` methods.
+#[doc(hidden)]
+#[macro_export]
+macro_rules! unit_match_arms {
+    ($(($variant:ident, $name:expr)),* $(,)?) => {
+        $(
+            UnitId::$variant => $name
+        ),*
+    };
+}
+
+/// Internal helper macro for generating unit `from_u32` match arms.
+#[doc(hidden)]
+#[macro_export]
+macro_rules! unit_from_u32_arms {
+    ($(($discriminant:expr, $variant:ident)),* $(,)?) => {
+        $(
+            $discriminant => Some(UnitId::$variant)
+        ),*
+    };
+}
+
+/// Internal helper macro for generating registry metadata match arms.
+#[doc(hidden)]
+#[macro_export]
+macro_rules! registry_match_arms {
+    ($(($variant:ident, $dim:ident, $scale:expr, $name:expr)),* $(,)?) => {
+        $(
+            UnitId::$variant => Some(UnitMeta {
+                dim: DimensionId::$dim,
+                scale_to_canonical: $scale,
+                name: $name,
+            })
+        ),*
+    };
+}
+
+/// Implements `From<$qty_type>` for `QttyQuantity` and `TryFrom<QttyQuantity>` for `$qty_type`.
+///
+/// This macro generates bidirectional conversion implementations between a specific
+/// `qtty` quantity type (like `Meters`, `Seconds`, etc.) and the FFI-safe [`QttyQuantity`] type.
+///
+/// # Arguments
+///
+/// * `$qty_type` - The `qtty` quantity type (e.g., `qtty::length::Meters`)
+/// * `$unit_id` - The corresponding [`UnitId`] variant (e.g., `UnitId::Meter`)
+///
+/// # Generated Implementations
+///
+/// * `impl From<$qty_type> for QttyQuantity` - Converts the typed quantity to FFI format
+/// * `impl TryFrom<QttyQuantity> for $qty_type` - Converts FFI format back to typed quantity,
+///   performing unit conversion if the FFI quantity is in a compatible unit
+///
+/// # Example
+///
+/// The macro is used internally by `qtty-ffi` to implement conversions for standard types.
+/// For your own types, usage looks like:
+///
+/// ```rust,ignore
+/// use qtty_ffi::{impl_unit_ffi, QttyQuantity, UnitId};
+///
+/// // Your custom type (defined in your crate)
+/// struct MySeconds(f64);
+/// impl MySeconds {
+///     fn new(v: f64) -> Self { Self(v) }
+///     fn value(&self) -> f64 { self.0 }
+/// }
+///
+/// impl_unit_ffi!(MySeconds, UnitId::Second);
+/// ```
+#[macro_export]
+macro_rules! impl_unit_ffi {
+    ($qty_type:ty, $unit_id:expr) => {
+        impl From<$qty_type> for $crate::QttyQuantity {
+            #[inline]
+            fn from(qty: $qty_type) -> Self {
+                $crate::QttyQuantity::new(qty.value(), $unit_id)
+            }
+        }
+
+        impl core::convert::TryFrom<$crate::QttyQuantity> for $qty_type {
+            type Error = i32;
+
+            #[inline]
+            fn try_from(qty: $crate::QttyQuantity) -> Result<Self, Self::Error> {
+                // If already the right unit, just wrap
+                if qty.unit == $unit_id {
+                    return Ok(<$qty_type>::new(qty.value));
+                }
+
+                // Otherwise, try to convert
+                let converted = $crate::registry::convert_value(qty.value, qty.unit, $unit_id)?;
+                Ok(<$qty_type>::new(converted))
+            }
+        }
+    };
+}

package/qtty-js/qtty/qtty-ffi/src/registry.rs

@@ -0,0 +1,274 @@
+//! Unit registry and conversion logic for FFI.
+//!
+//! This module provides a Rust-only unit registry that maps [`UnitId`] values to their
+//! metadata (dimension, scaling factor, name) and implements conversion between compatible units.
+//!
+//! # Conversion Formula
+//!
+//! Conversions use a canonical unit per dimension:
+//! - Length: Meter
+//! - Time: Second
+//! - Angle: Radian
+//!
+//! The conversion formula is:
+//! ```text
+//! v_canonical = v_src * src.scale_to_canonical
+//! v_dst = v_canonical / dst.scale_to_canonical
+//! ```
+//!
+//! Which simplifies to:
+//! ```text
+//! v_dst = v_src * (src.scale_to_canonical / dst.scale_to_canonical)
+//! ```
+
+use crate::types::{
+    DimensionId, UnitId, QTTY_ERR_INCOMPATIBLE_DIM, QTTY_ERR_UNKNOWN_UNIT, QTTY_OK,
+};
+
+// =============================================================================
+// Unit Metadata
+// =============================================================================
+
+/// Metadata about a unit for internal registry use.
+///
+/// This struct is Rust-only and not exposed via FFI.
+#[derive(Debug, Clone, Copy)]
+pub struct UnitMeta {
+    /// The dimension this unit belongs to.
+    pub dim: DimensionId,
+    /// Scaling factor to convert to the canonical unit for this dimension.
+    ///
+    /// For example, for Kilometer: `scale_to_canonical = 1000.0` (1 km = 1000 m)
+    pub scale_to_canonical: f64,
+    /// Human-readable name of the unit.
+    pub name: &'static str,
+}
+
+// =============================================================================
+// Registry Functions
+// =============================================================================
+
+/// Returns metadata for the given unit ID.
+///
+/// Returns `None` if the unit ID is not recognized.
+#[inline]
+pub fn meta(id: UnitId) -> Option<UnitMeta> {
+    include!(concat!(env!("OUT_DIR"), "/unit_registry.rs"))
+}
+
+/// Returns the dimension for the given unit ID.
+///
+/// Returns `None` if the unit ID is not recognized.
+#[inline]
+pub fn dimension(id: UnitId) -> Option<DimensionId> {
+    meta(id).map(|m| m.dim)
+}
+
+/// Checks if two units are compatible (same dimension).
+///
+/// Returns `true` if both units have the same dimension, `false` otherwise.
+/// Also returns `false` if either unit is not recognized.
+#[inline]
+pub fn compatible(a: UnitId, b: UnitId) -> bool {
+    match (dimension(a), dimension(b)) {
+        (Some(da), Some(db)) => da == db,
+        _ => false,
+    }
+}
+
+/// Converts a value from one unit to another.
+///
+/// # Arguments
+///
+/// * `v` - The value to convert
+/// * `src` - The source unit
+/// * `dst` - The destination unit
+///
+/// # Returns
+///
+/// * `Ok(converted_value)` on success
+/// * `Err(QTTY_ERR_UNKNOWN_UNIT)` if either unit is not recognized
+/// * `Err(QTTY_ERR_INCOMPATIBLE_DIM)` if units have different dimensions
+///
+/// # Example
+///
+/// ```rust
+/// use qtty_ffi::{registry, UnitId};
+///
+/// let meters = registry::convert_value(1000.0, UnitId::Meter, UnitId::Kilometer);
+/// assert!((meters.unwrap() - 1.0).abs() < 1e-12);
+/// ```
+#[inline]
+pub fn convert_value(v: f64, src: UnitId, dst: UnitId) -> Result<f64, i32> {
+    let src_meta = meta(src).ok_or(QTTY_ERR_UNKNOWN_UNIT)?;
+    let dst_meta = meta(dst).ok_or(QTTY_ERR_UNKNOWN_UNIT)?;
+
+    if src_meta.dim != dst_meta.dim {
+        return Err(QTTY_ERR_INCOMPATIBLE_DIM);
+    }
+
+    // If same unit, no conversion needed
+    if src == dst {
+        return Ok(v);
+    }
+
+    // Convert: v_canonical = v * src_scale, then v_dst = v_canonical / dst_scale
+    let v_canonical = v * src_meta.scale_to_canonical;
+    let v_dst = v_canonical / dst_meta.scale_to_canonical;
+
+    Ok(v_dst)
+}
+
+/// Converts a value from one unit to another, returning a status code.
+///
+/// This is a convenience function that returns `QTTY_OK` on success and
+/// the appropriate error code on failure. The converted value is stored
+/// in `result` (which must be initialized).
+///
+/// # Arguments
+///
+/// * `v` - The value to convert
+/// * `src` - The source unit
+/// * `dst` - The destination unit
+/// * `result` - Mutable reference to store the converted value
+///
+/// # Returns
+///
+/// * `QTTY_OK` on success
+/// * `QTTY_ERR_UNKNOWN_UNIT` if either unit is not recognized
+/// * `QTTY_ERR_INCOMPATIBLE_DIM` if units have different dimensions
+#[inline]
+pub fn convert_value_status(v: f64, src: UnitId, dst: UnitId, result: &mut f64) -> i32 {
+    match convert_value(v, src, dst) {
+        Ok(converted) => {
+            *result = converted;
+            QTTY_OK
+        }
+        Err(code) => code,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use approx::assert_relative_eq;
+    use core::f64::consts::PI;
+
+    #[test]
+    fn test_meta_returns_correct_dimensions() {
+        assert_eq!(meta(UnitId::Meter).unwrap().dim, DimensionId::Length);
+        assert_eq!(meta(UnitId::Kilometer).unwrap().dim, DimensionId::Length);
+        assert_eq!(meta(UnitId::Second).unwrap().dim, DimensionId::Time);
+        assert_eq!(meta(UnitId::Minute).unwrap().dim, DimensionId::Time);
+        assert_eq!(meta(UnitId::Hour).unwrap().dim, DimensionId::Time);
+        assert_eq!(meta(UnitId::Day).unwrap().dim, DimensionId::Time);
+        assert_eq!(meta(UnitId::Radian).unwrap().dim, DimensionId::Angle);
+        assert_eq!(meta(UnitId::Degree).unwrap().dim, DimensionId::Angle);
+    }
+
+    #[test]
+    fn test_compatible_same_dimension() {
+        assert!(compatible(UnitId::Meter, UnitId::Kilometer));
+        assert!(compatible(UnitId::Second, UnitId::Hour));
+        assert!(compatible(UnitId::Radian, UnitId::Degree));
+    }
+
+    #[test]
+    fn test_compatible_different_dimension() {
+        assert!(!compatible(UnitId::Meter, UnitId::Second));
+        assert!(!compatible(UnitId::Hour, UnitId::Radian));
+        assert!(!compatible(UnitId::Degree, UnitId::Kilometer));
+    }
+
+    #[test]
+    fn test_convert_meters_to_kilometers() {
+        let result = convert_value(1000.0, UnitId::Meter, UnitId::Kilometer).unwrap();
+        assert_relative_eq!(result, 1.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn test_convert_kilometers_to_meters() {
+        let result = convert_value(1.0, UnitId::Kilometer, UnitId::Meter).unwrap();
+        assert_relative_eq!(result, 1000.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn test_convert_seconds_to_minutes() {
+        let result = convert_value(60.0, UnitId::Second, UnitId::Minute).unwrap();
+        assert_relative_eq!(result, 1.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn test_convert_seconds_to_hours() {
+        let result = convert_value(3600.0, UnitId::Second, UnitId::Hour).unwrap();
+        assert_relative_eq!(result, 1.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn test_convert_hours_to_seconds() {
+        let result = convert_value(1.0, UnitId::Hour, UnitId::Second).unwrap();
+        assert_relative_eq!(result, 3600.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn test_convert_days_to_hours() {
+        let result = convert_value(1.0, UnitId::Day, UnitId::Hour).unwrap();
+        assert_relative_eq!(result, 24.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn test_convert_degrees_to_radians() {
+        let result = convert_value(180.0, UnitId::Degree, UnitId::Radian).unwrap();
+        assert_relative_eq!(result, PI, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn test_convert_radians_to_degrees() {
+        let result = convert_value(PI, UnitId::Radian, UnitId::Degree).unwrap();
+        assert_relative_eq!(result, 180.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn test_convert_same_unit() {
+        let result = convert_value(42.0, UnitId::Meter, UnitId::Meter).unwrap();
+        assert_relative_eq!(result, 42.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn test_convert_incompatible_dimensions() {
+        let result = convert_value(1.0, UnitId::Meter, UnitId::Second);
+        assert_eq!(result, Err(QTTY_ERR_INCOMPATIBLE_DIM));
+    }
+
+    #[test]
+    fn test_convert_preserves_special_values() {
+        // NaN
+        let nan_result = convert_value(f64::NAN, UnitId::Meter, UnitId::Kilometer).unwrap();
+        assert!(nan_result.is_nan());
+
+        // Infinity
+        let inf_result = convert_value(f64::INFINITY, UnitId::Second, UnitId::Minute).unwrap();
+        assert!(inf_result.is_infinite() && inf_result.is_sign_positive());
+
+        // Negative infinity
+        let neg_inf_result =
+            convert_value(f64::NEG_INFINITY, UnitId::Second, UnitId::Minute).unwrap();
+        assert!(neg_inf_result.is_infinite() && neg_inf_result.is_sign_negative());
+    }
+
+    #[test]
+    fn test_convert_value_status_success() {
+        let mut out = 0.0;
+        let status = convert_value_status(2.0, UnitId::Hour, UnitId::Minute, &mut out);
+        assert_eq!(status, QTTY_OK);
+        assert_relative_eq!(out, 120.0, epsilon = 1e-12);
+    }
+
+    #[test]
+    fn test_convert_value_status_incompatible_dimension() {
+        let mut out = -1.0;
+        let status = convert_value_status(1.0, UnitId::Meter, UnitId::Second, &mut out);
+        assert_eq!(status, QTTY_ERR_INCOMPATIBLE_DIM);
+        assert_relative_eq!(out, -1.0, epsilon = 1e-12);
+    }
+}