qubit-common 0.6.2

Foundational utilities and language-level tools for Rust application development
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
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190

/*******************************************************************************
 *
 *    Copyright (c) 2025 - 2026.
 *    Haixing Hu, Qubit Co. Ltd.
 *
 *    All rights reserved.
 *
 ******************************************************************************/
use qubit_common::{
    NumericArgument,
    require_equal,
    require_not_equal,
};

#[test]
fn zero_and_non_zero() {
    assert!(0i32.require_zero("v").is_ok());
    assert!(1i32.require_zero("v").is_err());
    assert!(0u32.require_non_zero("v").is_err());
    assert!(5u32.require_non_zero("v").is_ok());
    assert!(0.0f64.require_zero("v").is_ok());
    assert!((-0.0f64).require_non_zero("v").is_err());
}

#[test]
fn sign_related_checks() {
    // positive / non-negative
    assert!(10i32.require_positive("a").is_ok());
    assert!(0i32.require_positive("a").is_err());
    assert!((-1i32).require_positive("a").is_err());
    assert!(0i32.require_non_negative("a").is_ok());
    assert!((-1i32).require_non_negative("a").is_err());

    // negative / non-positive
    assert!((-5i32).require_negative("b").is_ok());
    assert!(0i32.require_negative("b").is_err());
    assert!(5i32.require_negative("b").is_err());
    assert!(0i32.require_non_positive("b").is_ok());
    assert!((5i32).require_non_positive("b").is_err());
}

#[test]
fn range_checks_closed_open_variants_with_integers() {
    // closed [min,max]
    assert!(5i32.require_in_closed_range("x", 1, 10).is_ok());
    assert!(1i32.require_in_closed_range("x", 1, 10).is_ok());
    assert!(10i32.require_in_closed_range("x", 1, 10).is_ok());
    assert!(0i32.require_in_closed_range("x", 1, 10).is_err());
    assert!(11i32.require_in_closed_range("x", 1, 10).is_err());

    // open (min,max)
    assert!(5i32.require_in_open_range("x", 1, 10).is_ok());
    assert!(1i32.require_in_open_range("x", 1, 10).is_err());
    assert!(10i32.require_in_open_range("x", 1, 10).is_err());

    // left-open (min,max]
    assert!(5i32.require_in_left_open_range("x", 1, 10).is_ok());
    assert!(1i32.require_in_left_open_range("x", 1, 10).is_err());
    assert!(10i32.require_in_left_open_range("x", 1, 10).is_ok());

    // right-open [min,max)
    assert!(5i32.require_in_right_open_range("x", 1, 10).is_ok());
    assert!(1i32.require_in_right_open_range("x", 1, 10).is_ok());
    assert!(10i32.require_in_right_open_range("x", 1, 10).is_err());
}

#[test]
fn range_checks_min_greater_than_max_should_fail() {
    assert!(5i32.require_in_closed_range("x", 10, 1).is_err());
    assert!(5i32.require_in_open_range("x", 10, 1).is_err());
    assert!(5i32.require_in_left_open_range("x", 10, 1).is_err());
    assert!(5i32.require_in_right_open_range("x", 10, 1).is_err());
}

#[test]
fn comparison_checks() {
    assert!(5i32.require_less("x", 6).is_ok());
    assert!(5i32.require_less("x", 5).is_err());
    assert!(5i32.require_less_equal("x", 5).is_ok());
    assert!(6i32.require_less_equal("x", 5).is_err());

    assert!(6i32.require_greater("x", 5).is_ok());
    assert!(5i32.require_greater("x", 5).is_err());
    assert!(5i32.require_greater_equal("x", 5).is_ok());
    assert!(4i32.require_greater_equal("x", 5).is_err());
}

#[test]
fn free_functions_equal_and_not_equal() {
    assert!(require_equal("a", 100, "b", 100).is_ok());
    let err1 = require_equal("a", 100, "b", 200).unwrap_err();
    assert!(err1.message().contains("a"));

    assert!(require_not_equal("a", 1, "b", 2).is_ok());
    let err2 = require_not_equal("a", 2, "b", 2).unwrap_err();
    assert!(err2.message().contains("cannot be equal"));
}

#[test]
fn float_edge_cases_nan_and_infinite() {
    let nan = f64::NAN;
    assert!(nan.require_in_closed_range("f", -1.0, 1.0).is_err());
    assert!(nan.require_less("f", 0.0).is_err());
    assert!(nan.require_greater("f", 0.0).is_err());
    assert!(nan.require_zero("f").is_err());
    assert!(nan.require_non_zero("f").is_err());

    let inf = f64::INFINITY;
    assert!(inf.require_less("f", f64::MAX).is_err());
    assert!(inf.require_greater_equal("f", 0.0).is_ok());

    let ninf = f64::NEG_INFINITY;
    assert!(ninf.require_greater("f", f64::MIN).is_err());
    assert!(ninf.require_less_equal("f", 0.0).is_ok());
}

#[test]
fn float_range_bounds_nan_should_fail() {
    assert!(1.0f64.require_in_closed_range("f", f64::NAN, 1.0).is_err());
    assert!(1.0f64.require_in_closed_range("f", -1.0, f64::NAN).is_err());
    assert!(1.0f64.require_in_open_range("f", f64::NAN, 1.0).is_err());
    assert!(1.0f64.require_in_open_range("f", -1.0, f64::NAN).is_err());
}

#[test]
fn big_integer_edges() {
    let max = i128::MAX;
    let min = i128::MIN;
    assert!(max.require_in_closed_range("v", min, max).is_ok());
    assert!(min.require_in_closed_range("v", min, max).is_ok());

    let umax = u128::MAX;
    assert!(umax.require_greater_equal("u", 0u128).is_ok());
}

#[test]
fn f32_covers_numeric_value_impl_and_nan_checks() {
    assert!(0.0f32.require_zero("f").is_ok());
    assert!(1.0f32.require_non_zero("f").is_ok());
    assert!(f32::NAN.require_zero("f").is_err());
    assert!(f32::NAN.require_non_zero("f").is_err());

    assert!(1.0f32.require_positive("f").is_ok());
    assert!(0.0f32.require_positive("f").is_err());
    assert!(f32::NAN.require_positive("f").is_err());

    assert!(0.0f32.require_non_negative("f").is_ok());
    assert!((-1.0f32).require_non_negative("f").is_err());
    assert!(f32::NAN.require_non_negative("f").is_err());

    assert!((-1.0f32).require_negative("f").is_ok());
    assert!(0.0f32.require_negative("f").is_err());
    assert!(f32::NAN.require_negative("f").is_err());

    assert!(0.0f32.require_non_positive("f").is_ok());
    assert!(1.0f32.require_non_positive("f").is_err());
    assert!(f32::NAN.require_non_positive("f").is_err());

    assert!(0.5f32.require_in_closed_range("f", 0.0, 1.0).is_ok());
    assert!(f32::NAN.require_in_closed_range("f", 0.0, 1.0).is_err());
    assert!(0.5f32.require_in_closed_range("f", f32::NAN, 1.0).is_err());
    assert!(0.5f32.require_in_closed_range("f", 0.0, f32::NAN).is_err());

    assert!(0.5f32.require_in_open_range("f", 0.0, 1.0).is_ok());
    assert!(f32::NAN.require_in_open_range("f", 0.0, 1.0).is_err());

    assert!(0.5f32.require_less("f", 1.0).is_ok());
    assert!(f32::NAN.require_less("f", 1.0).is_err());
    assert!(0.5f32.require_less("f", f32::NAN).is_err());

    assert!(0.5f32.require_less_equal("f", 1.0).is_ok());
    assert!(f32::NAN.require_less_equal("f", 1.0).is_err());
    assert!(0.5f32.require_less_equal("f", f32::NAN).is_err());

    assert!(0.5f32.require_greater("f", 0.0).is_ok());
    assert!(f32::NAN.require_greater("f", 0.0).is_err());
    assert!(0.5f32.require_greater("f", f32::NAN).is_err());

    assert!(0.5f32.require_greater_equal("f", 0.0).is_ok());
    assert!(f32::NAN.require_greater_equal("f", 0.0).is_err());
    assert!(0.5f32.require_greater_equal("f", f32::NAN).is_err());
}

#[test]
fn f64_reject_nan_on_bound_arguments() {
    assert!(1.0f64.require_less("v", f64::NAN).is_err());
    assert!(1.0f64.require_less_equal("v", f64::NAN).is_err());
    assert!(1.0f64.require_greater("v", f64::NAN).is_err());
    assert!(1.0f64.require_greater_equal("v", f64::NAN).is_err());
}