blob: 1a94be01302cbb75acf44d763489b0757d7fef47 (
plain)
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
|
// Adapted from https://github.com/Alexhuszagh/rust-lexical.
use crate::lexical::num::{AsPrimitive, Float, Integer, Number};
fn check_as_primitive<T: AsPrimitive>(t: T) {
let _: u32 = t.as_u32();
let _: u64 = t.as_u64();
let _: u128 = t.as_u128();
let _: usize = t.as_usize();
let _: f32 = t.as_f32();
let _: f64 = t.as_f64();
}
#[test]
fn as_primitive_test() {
check_as_primitive(1u32);
check_as_primitive(1u64);
check_as_primitive(1u128);
check_as_primitive(1usize);
check_as_primitive(1f32);
check_as_primitive(1f64);
}
fn check_number<T: Number>(x: T, y: T) {
// Copy, partialeq, partialord
let _ = x;
assert!(x < y);
assert!(x != y);
// Operations
let _ = y + x;
// Conversions already tested.
}
#[test]
fn number_test() {
check_number(1u32, 5);
check_number(1u64, 5);
check_number(1u128, 5);
check_number(1usize, 5);
check_number(1f32, 5.0);
check_number(1f64, 5.0);
}
fn check_integer<T: Integer>(x: T) {
// Bitwise operations
let _ = x & T::ZERO;
}
#[test]
fn integer_test() {
check_integer(65u32);
check_integer(65u64);
check_integer(65u128);
check_integer(65usize);
}
fn check_float<T: Float>(x: T) {
// Check functions
let _ = x.pow10(5);
let _ = x.to_bits();
assert!(T::from_bits(x.to_bits()) == x);
// Check properties
let _ = x.to_bits() & T::SIGN_MASK;
let _ = x.to_bits() & T::EXPONENT_MASK;
let _ = x.to_bits() & T::HIDDEN_BIT_MASK;
let _ = x.to_bits() & T::MANTISSA_MASK;
}
#[test]
fn float_test() {
check_float(123f32);
check_float(123f64);
}
|
