qubit-argument 0.4.1

Structured, ownership-preserving argument validation for Rust applications
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72

// =============================================================================
//    Copyright (c) 2025 - 2026 Haixing Hu.
//
//    SPDX-License-Identifier: Apache-2.0
//
//    Licensed under the Apache License, Version 2.0.
// =============================================================================
//! Tests for finite floating-point argument validation.

use qubit_argument::{
    ArgumentErrorKind,
    ArgumentValue,
    FloatArgument,
};

/// Verifies that finite 32-bit and 64-bit values are returned unchanged.
#[test]
fn test_require_finite_preserves_finite_values() {
    assert_eq!(
        (-0.0_f32)
            .require_finite("factor")
            .expect("negative zero is finite")
            .to_bits(),
        (-0.0_f32).to_bits(),
    );
    assert_eq!(
        1.5_f64
            .require_finite("factor")
            .expect("one and a half is finite"),
        1.5,
    );
}

/// Verifies that positive infinity retains its exact 32-bit representation.
#[test]
fn test_require_finite_rejects_positive_infinity() {
    let error = f32::INFINITY
        .require_finite("jitter.factor")
        .expect_err("positive infinity is not finite");
    assert_eq!(error.path().as_str(), "jitter.factor");
    assert_eq!(
        error.kind(),
        &ArgumentErrorKind::NotFinite {
            actual: ArgumentValue::from(f32::INFINITY),
        },
    );
}

/// Verifies that negative infinity retains its exact 64-bit representation.
#[test]
fn test_require_finite_rejects_negative_infinity() {
    let error = f64::NEG_INFINITY
        .require_finite("multiplier")
        .expect_err("negative infinity is not finite");
    assert_eq!(error.path().as_str(), "multiplier");
    assert_eq!(
        error.kind(),
        &ArgumentErrorKind::NotFinite {
            actual: ArgumentValue::from(f64::NEG_INFINITY),
        },
    );
}

/// Verifies that NaN keeps the established not-a-number classification.
#[test]
fn test_require_finite_reports_not_a_number_for_nan() {
    let error = f64::NAN
        .require_finite("multiplier")
        .expect_err("NaN is not a number");
    assert_eq!(error.path().as_str(), "multiplier");
    assert_eq!(error.kind(), &ArgumentErrorKind::NotANumber);
}