siderust-js 0.1.0

package/qtty-js/qtty/qtty/tests/fixtures/qtty-vec-std/Cargo.lock

@@ -0,0 +1,83 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "libm"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6d2cec3eae94f9f509c767b45932f1ada8350c4bdb85af2fcab4a3c14807981"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.106"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "qtty"
+version = "0.4.0"
+dependencies = [
+ "qtty-core",
+ "qtty-derive",
+]
+
+[[package]]
+name = "qtty-core"
+version = "0.4.0"
+dependencies = [
+ "libm",
+ "qtty-derive",
+ "typenum",
+]
+
+[[package]]
+name = "qtty-derive"
+version = "0.4.0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "qtty-vec-std-fixture"
+version = "0.0.0"
+dependencies = [
+ "qtty",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21b2ebcf727b7760c461f091f9f0f539b77b8e87f2fd88131e7f1b433b3cece4"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "syn"
+version = "2.0.114"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4d107df263a3013ef9b1879b0df87d706ff80f65a86ea879bd9c31f9b307c2a"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "typenum"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "537dd038a89878be9b64dd4bd1b260315c1bb94f4d784956b81e27a088d9a09e"

package/qtty-js/qtty/qtty/tests/fixtures/qtty-vec-std/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "qtty-vec-std-fixture"
+version = "0.0.0"
+edition = "2021"
+publish = false
+
+[dependencies]
+qtty = { path = "../../.." }
+
+[workspace]

package/qtty-js/qtty/qtty/tests/fixtures/qtty-vec-std/src/lib.rs

@@ -0,0 +1,5 @@
+use qtty::Seconds;
+
+pub fn build_samples() -> Vec<Seconds> {
+    qtty::qtty_vec!(vec Seconds; 1.0, 2.0, 3.0)
+}

package/qtty-js/qtty/qtty/tests/integration_tests.rs

@@ -0,0 +1,529 @@
+//! Integration-level smoke tests for the `qtty` facade crate.
+
+use qtty::*;
+
+use approx::{assert_abs_diff_eq, assert_relative_eq};
+
+#[test]
+fn smoke_test_angular() {
+    let deg = Degrees::new(180.0);
+    let rad: Radians = deg.to();
+    assert_abs_diff_eq!(rad.value(), std::f64::consts::PI, epsilon = 1e-12);
+}
+
+#[test]
+fn smoke_test_time() {
+    let day = Days::new(1.0);
+    let sec: Seconds = day.to();
+    assert_abs_diff_eq!(sec.value(), 86400.0, epsilon = 1e-9);
+}
+
+#[test]
+fn smoke_test_length() {
+    let km = Kilometers::new(1.0);
+    let m: Meters = km.to();
+    assert_abs_diff_eq!(m.value(), 1000.0, epsilon = 1e-9);
+}
+
+#[test]
+fn smoke_test_mass() {
+    let kg = Kilograms::new(1000.0);
+    let g: Grams = kg.to();
+    assert_abs_diff_eq!(g.value(), 1_000_000.0, epsilon = 1e-6);
+}
+
+#[test]
+fn smoke_test_power() {
+    let sol = SolarLuminosities::new(1.0);
+    let w: Watts = sol.to();
+    assert_relative_eq!(w.value(), 3.828e26, max_relative = 1e-9);
+}
+
+#[test]
+fn smoke_test_velocity() {
+    let v: velocity::Velocity<Kilometer, Second> = velocity::Velocity::new(1.0);
+    let v_mps: velocity::Velocity<Meter, Second> = v.to();
+    assert_abs_diff_eq!(v_mps.value(), 1000.0, epsilon = 1e-9);
+}
+
+#[test]
+fn smoke_test_frequency() {
+    let f: frequency::Frequency<Degree, Day> = frequency::Frequency::new(360.0);
+    let f_rad: frequency::Frequency<Radian, Day> = f.to();
+    assert_abs_diff_eq!(f_rad.value(), 2.0 * std::f64::consts::PI, epsilon = 1e-12);
+}
+
+#[test]
+fn smoke_test_unitless() {
+    let m = Meters::new(42.0);
+    let u: Quantity<Unitless> = m.into();
+    assert_eq!(u.value(), 42.0);
+}
+
+#[test]
+fn smoke_test_unitless_from_time() {
+    let s = Seconds::new(5.0);
+    let u: Quantity<Unitless> = s.into();
+    assert_eq!(u.value(), 5.0);
+}
+
+#[test]
+fn smoke_test_unitless_from_mass() {
+    let kg = Kilograms::new(2.0);
+    let u: Quantity<Unitless> = kg.into();
+    assert_eq!(u.value(), 2.0);
+}
+
+#[test]
+fn smoke_test_unitless_from_angular() {
+    let deg = Degrees::new(15.0);
+    let u: Quantity<Unitless> = deg.into();
+    assert_eq!(u.value(), 15.0);
+}
+
+#[test]
+fn orbital_distance_calculation() {
+    // Earth's orbital velocity ≈ 29.78 km/s
+    let earth_velocity: velocity::Velocity<Kilometer, Second> = velocity::Velocity::new(29.78);
+
+    // Time: 1 day
+    let time = Days::new(1.0);
+    let time_sec: Seconds = time.to();
+
+    // Distance = velocity × time
+    let distance: Kilometers = (earth_velocity * time_sec).to();
+
+    // Earth travels about 2.57 million km per day
+    assert_relative_eq!(distance.value(), 2_573_395.2, max_relative = 1e-3);
+}
+
+#[test]
+fn proxima_centauri_distance() {
+    // Proxima Centauri is about 4.24 light years away
+    let distance_ly = LightYears::new(4.24);
+
+    // Convert to AU
+    let distance_au: AstronomicalUnits = distance_ly.to();
+
+    // Should be about 268,000 AU
+    assert_relative_eq!(distance_au.value(), 268_000.0, max_relative = 0.01);
+}
+
+#[test]
+fn angular_separation() {
+    // Two stars at different positions
+    let star1_ra = Degrees::new(45.0);
+    let star2_ra = Degrees::new(350.0);
+
+    // Separation should wrap around
+    let sep = star1_ra.abs_separation(star2_ra);
+
+    // 45° to 350° is 55° the short way
+    assert_abs_diff_eq!(sep.value(), 55.0, epsilon = 1e-12);
+}
+
+#[test]
+fn earth_rotation() {
+    // Earth rotates 360° per sidereal day (~23h 56m)
+    let rotation_rate: frequency::Frequency<Degree, Day> = frequency::Frequency::new(360.0);
+
+    // After 6 hours (0.25 days)
+    let time = Days::new(0.25);
+    let angle: Degrees = (rotation_rate * time).to();
+
+    assert_abs_diff_eq!(angle.value(), 90.0, epsilon = 1e-12);
+}
+
+#[test]
+fn sun_mass() {
+    let sun = SolarMasses::new(1.0);
+    let kg: Kilograms = sun.to();
+
+    // Sun's mass is about 2e30 kg
+    assert_relative_eq!(kg.value(), 1.988416e30, max_relative = 1e-5);
+}
+
+#[test]
+fn sun_luminosity() {
+    let sun = SolarLuminosities::new(1.0);
+    let watts: Watts = sun.to();
+
+    // Sun's luminosity is about 3.828e26 W
+    assert_relative_eq!(watts.value(), 3.828e26, max_relative = 1e-9);
+}
+
+#[test]
+fn calculate_velocity_from_distance_time() {
+    // Light year to km
+    let distance = LightYears::new(1.0);
+    let distance_km: Kilometers = distance.to();
+
+    // Julian year to seconds
+    let time = JulianYears::new(1.0);
+    let time_sec: Seconds = time.to();
+
+    // Velocity = distance / time
+    let velocity: velocity::Velocity<Kilometer, Second> = distance_km / time_sec;
+
+    // Should be approximately speed of light (299,792 km/s)
+    assert_relative_eq!(velocity.value(), 299_792.458, max_relative = 0.001);
+}
+
+#[test]
+fn mean_motion_conversion() {
+    // Earth's mean motion ≈ 0.9856°/day
+    let mean_motion: frequency::Frequency<Degree, Day> = frequency::Frequency::new(0.9856);
+
+    // Convert to degrees per year
+    let per_year: frequency::Frequency<Degree, Year> = mean_motion.to();
+
+    // Should be about 360°/year
+    assert_relative_eq!(per_year.value(), 360.0, max_relative = 0.01);
+}
+
+#[test]
+fn trigonometric_calculation() {
+    // 30° angle
+    let angle = Degrees::new(30.0);
+
+    // sin(30°) = 0.5
+    assert_abs_diff_eq!(angle.sin(), 0.5, epsilon = 1e-12);
+
+    // cos(30°) = √3/2
+    assert_abs_diff_eq!(angle.cos(), 3.0_f64.sqrt() / 2.0, epsilon = 1e-12);
+
+    // tan(30°) = 1/√3
+    assert_abs_diff_eq!(angle.tan(), 1.0 / 3.0_f64.sqrt(), epsilon = 1e-12);
+}
+
+#[test]
+fn derive_macro_produces_correct_symbol() {
+    // Verify that units defined with derive macro have correct symbols
+    assert_eq!(Meter::SYMBOL, "m");
+    assert_eq!(Kilometer::SYMBOL, "km");
+    assert_eq!(Second::SYMBOL, "s");
+    assert_eq!(Day::SYMBOL, "d");
+    assert_eq!(Degree::SYMBOL, "°");
+    assert_eq!(Radian::SYMBOL, "rad");
+}
+
+#[test]
+fn derive_macro_produces_correct_ratio() {
+    // Verify ratios are correct
+    assert_eq!(Meter::RATIO, 1.0);
+    assert_eq!(Kilometer::RATIO, 1000.0);
+    assert_eq!(Second::RATIO, 1.0);
+    assert_eq!(Degree::RATIO, 1.0);
+}
+
+#[test]
+fn derive_macro_display_formatting() {
+    let m = Meters::new(42.0);
+    assert_eq!(format!("{}", m), "42 m");
+
+    let km = Kilometers::new(1.5);
+    assert_eq!(format!("{}", km), "1.5 km");
+
+    let deg = Degrees::new(90.0);
+    assert_eq!(format!("{}", deg), "90 °");
+}
+
+#[test]
+fn display_format_precision() {
+    let x = Seconds::new(1234.56789);
+    // {:.2} → two decimal places
+    assert_eq!(format!("{:.2}", x), "1234.57 s");
+    // {:.0} → no decimal places (rounded)
+    assert_eq!(format!("{:.0}", x), "1235 s");
+    // {:.5} → five decimal places
+    assert_eq!(format!("{:.5}", x), "1234.56789 s");
+}
+
+#[test]
+fn display_lower_exp_formatting() {
+    let x = Seconds::new(1234.56789);
+    // {:e} → default scientific notation (lower-case e)
+    assert_eq!(format!("{:e}", x), "1.23456789e3 s");
+    // {:.4e} → precision + scientific
+    assert_eq!(format!("{:.4e}", x), "1.2346e3 s");
+    // {:.0e} → zero decimal places
+    assert_eq!(format!("{:.0e}", x), "1e3 s");
+}
+
+#[test]
+fn display_upper_exp_formatting() {
+    let x = Seconds::new(1234.56789);
+    // {:E} → scientific notation upper-case E
+    assert_eq!(format!("{:E}", x), "1.23456789E3 s");
+    // {:.4E} → precision + upper-case scientific
+    assert_eq!(format!("{:.4E}", x), "1.2346E3 s");
+}
+
+#[test]
+fn display_format_annotations_per_unit() {
+    let v: velocity::Velocity<Kilometer, Second> = velocity::Velocity::new(1234.56789);
+    // Default
+    assert_eq!(format!("{}", v), "1234.56789 km/s");
+    // Precision
+    assert_eq!(format!("{:.2}", v), "1234.57 km/s");
+    // Scientific lower
+    assert_eq!(format!("{:.4e}", v), "1.2346e3 km/s");
+    // Scientific upper
+    assert_eq!(format!("{:.4E}", v), "1.2346E3 km/s");
+}
+
+#[test]
+fn display_sign_and_negative_values() {
+    let neg = Meters::new(-42.5);
+    assert_eq!(format!("{}", neg), "-42.5 m");
+    assert_eq!(format!("{:.1}", neg), "-42.5 m");
+    assert_eq!(format!("{:.2e}", neg), "-4.25e1 m");
+}
+
+#[test]
+fn quantity_basic_arithmetic() {
+    let a = Meters::new(10.0);
+    let b = Meters::new(5.0);
+
+    assert_eq!((a + b).value(), 15.0);
+    assert_eq!((a - b).value(), 5.0);
+    assert_eq!((a * 2.0).value(), 20.0);
+    assert_eq!((a / 2.0).value(), 5.0);
+}
+
+#[test]
+fn quantity_conversion_chain() {
+    // Convert through multiple units
+    let au = AstronomicalUnits::new(1.0);
+    let km: Kilometers = au.to();
+    let m: Meters = km.to();
+
+    // Direct conversion should match
+    let m_direct: Meters = au.to();
+    assert_abs_diff_eq!(m.value(), m_direct.value(), epsilon = 1e-3);
+}
+
+#[test]
+fn quantity_negation() {
+    let pos = Degrees::new(45.0);
+    let neg = -pos;
+    assert_eq!(neg.value(), -45.0);
+}
+
+#[test]
+fn quantity_abs() {
+    let neg = Degrees::new(-45.0);
+    assert_eq!(neg.abs().value(), 45.0);
+}
+
+#[test]
+fn per_unit_display() {
+    let v: velocity::Velocity<Kilometer, Second> = velocity::Velocity::new(10.0);
+    let s = format!("{}", v);
+    assert_eq!(s, "10 km/s");
+}
+
+#[test]
+fn per_unit_multiplication_recovers_numerator() {
+    let v: velocity::Velocity<Kilometer, Second> = velocity::Velocity::new(100.0);
+    let t: Seconds = Seconds::new(3600.0);
+    let d: Kilometers = (v * t).to();
+    assert_abs_diff_eq!(d.value(), 360_000.0, epsilon = 1e-6);
+}
+
+#[test]
+fn qtty_values_macro_builds_seconds_array() {
+    const DT: [Seconds; 3] = qtty::qtty_vec!(Seconds; 56.86, 63.83, 70.0);
+    assert_abs_diff_eq!(DT[0].value(), 56.86, epsilon = 1e-12);
+    assert_abs_diff_eq!(DT[1].value(), 63.83, epsilon = 1e-12);
+    assert_abs_diff_eq!(DT[2].value(), 70.0, epsilon = 1e-12);
+}
+
+#[test]
+fn qtty_values_macro_builds_seconds_vec() {
+    let dt: Vec<Seconds> = qtty::qtty_vec!(vec Seconds; 56.86, 63.83, 70.0);
+    assert_eq!(dt.len(), 3);
+    assert_abs_diff_eq!(dt[1].value(), 63.83, epsilon = 1e-12);
+}
+
+#[test]
+fn per_unit_division_creates_composite() {
+    let d = Kilometers::new(100.0);
+    let t = Seconds::new(10.0);
+    let v: velocity::Velocity<Kilometer, Second> = d / t;
+    assert_abs_diff_eq!(v.value(), 10.0, epsilon = 1e-12);
+}
+
+#[test]
+fn unit_constants_have_value_one() {
+    assert_eq!(AU.value(), 1.0);
+    assert_eq!(LY.value(), 1.0);
+    assert_eq!(KM.value(), 1.0);
+    assert_eq!(DAY.value(), 1.0);
+    assert_eq!(SEC.value(), 1.0);
+    assert_eq!(DEG.value(), 1.0);
+    assert_eq!(RAD.value(), 1.0);
+}
+
+#[test]
+fn constants_can_be_multiplied() {
+    let distance = 4.24 * LY;
+    assert_eq!(distance.value(), 4.24);
+
+    let time = 365.25 * DAY;
+    assert_eq!(time.value(), 365.25);
+}
+
+#[test]
+fn macro_generated_conversions() {
+    // Test conversions that are now generated by impl_unit_conversions! macro
+    // These weren't manually implemented before
+
+    // Meter -> AstronomicalUnit (AU is exactly 149,597,870,700 m)
+    let m = Meters::new(149_597_870_700.0);
+    let au: AstronomicalUnits = m.into();
+    assert_relative_eq!(au.value(), 1.0, max_relative = 1e-12);
+
+    // Nominal SolarRadius -> Kilometer
+    use qtty_core::length::nominal::SolarRadiuses;
+    let sr = SolarRadiuses::new(1.0);
+    let km: Kilometers = sr.into();
+    assert_abs_diff_eq!(km.value(), 695_700.0, epsilon = 1e-6);
+
+    // Parsec -> AstronomicalUnit
+    let pc = Parsecs::new(1.0);
+    let au: AstronomicalUnits = pc.into();
+    // 1 pc = au * 648000 / π
+    let expected = 648_000.0 / core::f64::consts::PI;
+    assert_relative_eq!(au.value(), expected, max_relative = 1e-12);
+}
+
+#[test]
+fn new_angular_units() {
+    // Test the new angular units added via impl_unit_conversions! macro
+
+    // Arcminute conversions
+    let deg = Degrees::new(1.0);
+    let arcm: Arcminutes = deg.into();
+    assert_abs_diff_eq!(arcm.value(), 60.0, epsilon = 1e-12);
+
+    // Microarcsecond conversions
+    let arcs = Arcseconds::new(1.0);
+    let uas: MicroArcseconds = arcs.into();
+    assert_abs_diff_eq!(uas.value(), 1_000_000.0, epsilon = 1e-6);
+
+    // Gradian conversions (1 full turn = 400 gradians)
+    let turn = Turns::new(1.0);
+    let gon: Gradians = turn.into();
+    assert_abs_diff_eq!(gon.value(), 400.0, epsilon = 1e-12);
+
+    // Turn conversions
+    let deg = Degrees::new(180.0);
+    let turn: Turns = deg.into();
+    assert_abs_diff_eq!(turn.value(), 0.5, epsilon = 1e-12);
+
+    // Test trig functions work with new units
+    let right_angle = Gradians::new(100.0); // 90 degrees
+    assert_abs_diff_eq!(right_angle.sin(), 1.0, epsilon = 1e-12);
+    assert_abs_diff_eq!(right_angle.cos(), 0.0, epsilon = 1e-12);
+
+    // Test wrapping with new units
+    let turn = Turns::new(2.7);
+    let wrapped = turn.wrap_pos();
+    assert_abs_diff_eq!(wrapped.value(), 0.7, epsilon = 1e-12);
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// f32 scalar type tests
+// ─────────────────────────────────────────────────────────────────────────────
+
+#[test]
+fn smoke_test_f32_angular() {
+    use qtty::f32::{Degrees, Radians};
+
+    let deg = Degrees::new(180.0_f32);
+    let rad: Radians = deg.to();
+    assert!((rad.value() - core::f32::consts::PI).abs() < 1e-5);
+}
+
+#[test]
+fn smoke_test_f32_length() {
+    use qtty::f32::{Kilometers, Meters};
+
+    let km = Kilometers::new(1.0_f32);
+    let m: Meters = km.to();
+    assert!((m.value() - 1000.0).abs() < 1e-4);
+}
+
+#[test]
+fn smoke_test_f32_time() {
+    use qtty::f32::{Days, Seconds};
+
+    let day = Days::new(1.0_f32);
+    let sec: Seconds = day.to();
+    assert!((sec.value() - 86400.0).abs() < 1.0);
+}
+
+#[test]
+fn smoke_test_f32_arithmetic() {
+    use qtty::f32::Meters;
+
+    let a = Meters::new(10.0_f32);
+    let b = Meters::new(5.0_f32);
+    let sum = a + b;
+    let diff = a - b;
+
+    assert!((sum.value() - 15.0).abs() < 1e-6);
+    assert!((diff.value() - 5.0).abs() < 1e-6);
+}
+
+#[test]
+fn smoke_test_f32_trig() {
+    use qtty::f32::Degrees;
+
+    let angle = Degrees::new(90.0_f32);
+    assert!((angle.sin() - 1.0).abs() < 1e-5);
+    assert!(angle.cos().abs() < 1e-5);
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Integer scalar module tests
+// ─────────────────────────────────────────────────────────────────────────────
+
+#[test]
+fn smoke_test_i8_module_arithmetic_and_lossy_conversion() {
+    use qtty::i8::{Meters, Minutes, Seconds};
+
+    let a = Meters::new(50);
+    let b = Meters::new(20);
+    assert_eq!((a + b).value(), 70);
+    assert_eq!((a - b).value(), 30);
+
+    let sec = Seconds::new(125);
+    let min: Minutes = sec.to_lossy();
+    assert_eq!(min.value(), 2);
+}
+
+#[test]
+fn smoke_test_i16_module_arithmetic_and_lossy_conversion() {
+    use qtty::i16::{Kilometers, Meters};
+
+    let a = Meters::new(1_500);
+    let b = Meters::new(250);
+    assert_eq!((a + b).value(), 1_750);
+
+    let km: Kilometers = a.to_lossy();
+    assert_eq!(km.value(), 1);
+}
+
+#[test]
+fn smoke_test_i128_module_arithmetic_and_lossy_conversion() {
+    use qtty::i128::{Days, Seconds};
+
+    let a = Seconds::new(172_800);
+    let b = Seconds::new(3_600);
+    assert_eq!((a + b).value(), 176_400);
+
+    let days: Days = a.to_lossy();
+    assert_eq!(days.value(), 2);
+}

package/qtty-js/qtty/qtty/tests/qtty_vec_feature_matrix.rs

@@ -0,0 +1,58 @@
+use std::path::{Path, PathBuf};
+use std::process::{Command, Output};
+
+fn fixture_manifest(name: &str) -> PathBuf {
+    Path::new(env!("CARGO_MANIFEST_DIR"))
+        .join("tests")
+        .join("fixtures")
+        .join(name)
+        .join("Cargo.toml")
+}
+
+fn cargo_check(manifest_path: &Path) -> Output {
+    let target_dir = Path::new(env!("CARGO_MANIFEST_DIR"))
+        .join("target")
+        .join("qtty-vec-feature-matrix");
+
+    Command::new(env!("CARGO"))
+        .arg("check")
+        .arg("--manifest-path")
+        .arg(manifest_path)
+        .current_dir(env!("CARGO_MANIFEST_DIR"))
+        .env("CARGO_TERM_COLOR", "never")
+        .env("CARGO_TARGET_DIR", target_dir)
+        .output()
+        .expect("failed to run cargo check")
+}
+
+#[test]
+fn qtty_vec_feature_matrix() {
+    let std_manifest = fixture_manifest("qtty-vec-std");
+    let std_out = cargo_check(&std_manifest);
+    assert!(
+        std_out.status.success(),
+        "std mode should compile\nstderr:\n{}",
+        String::from_utf8_lossy(&std_out.stderr)
+    );
+
+    let no_std_alloc_manifest = fixture_manifest("qtty-vec-no-std-alloc");
+    let no_std_alloc_out = cargo_check(&no_std_alloc_manifest);
+    assert!(
+        no_std_alloc_out.status.success(),
+        "no_std + alloc mode should compile\nstderr:\n{}",
+        String::from_utf8_lossy(&no_std_alloc_out.stderr)
+    );
+
+    let no_std_manifest = fixture_manifest("qtty-vec-no-std");
+    let no_std_out = cargo_check(&no_std_manifest);
+    assert!(
+        !no_std_out.status.success(),
+        "pure no_std mode should fail for vec form"
+    );
+
+    let stderr = String::from_utf8_lossy(&no_std_out.stderr);
+    assert!(
+        stderr.contains("requires the `std` or `alloc` feature"),
+        "expected a clear feature requirement in compiler output\nstderr:\n{stderr}"
+    );
+}