cmn 0.0.4

A Rust library for accessing a collection of mathematical and cryptographic constants
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

// Copyright © 2023 Common (CMN) library. All rights reserved.
// SPDX-License-Identifier: Apache-2.0 OR MIT

#[cfg(test)]
mod tests {
    use cmn::constants::{ConstantValue, Constants};

    #[test]
    fn test_constant() {
        let new_constant = Constants::new();
        let constant = new_constant.constant("EULER");
        assert!(constant.is_some());
        assert_eq!(constant.unwrap().name, "EULER");

        let constant = new_constant.constant("FAKE_CONSTANT");
        assert!(constant.is_none());
    }

    #[test]
    fn test_constants() {
        let new_constant = Constants::new();
        let constants = new_constant.constants();
        assert_eq!(constants.len(), 28);

        let names =
            constants.iter().map(|c| c.name).collect::<Vec<_>>();
        assert!(names.contains(&"APERY"));
        assert!(names.contains(&"AVOGADRO"));
        assert!(names.contains(&"BOLTZMANN"));
        assert!(names.contains(&"CATALAN"));
        assert!(names.contains(&"COULOMB"));
        assert!(names.contains(&"EULER"));
        assert!(names.contains(&"FARADAY"));
        assert!(names.contains(&"GAMMA"));
        assert!(names.contains(&"GAS_CONSTANT"));
        assert!(names.contains(&"GLAISHER_KINKELIN"));
        assert!(names.contains(&"GRAVITATIONAL_CONSTANT"));
        assert!(names.contains(&"HASH_ALGORITHM"));
        assert!(names.contains(&"HASH_COST"));
        assert!(names.contains(&"HASH_LENGTH"));
        assert!(names.contains(&"KHINCHIN"));
        assert!(names.contains(&"PHI"));
        assert!(names.contains(&"PI"));
        assert!(names.contains(&"PLANCK"));
        assert!(names.contains(&"PLANCK_REDUCED"));
        assert!(names.contains(&"SILVER_RATIO"));
        assert!(names.contains(&"SPEED_OF_LIGHT"));
        assert!(names.contains(&"SPECIAL_CHARS"));
        assert!(names.contains(&"SQRT2"));
        assert!(names.contains(&"SQRT3"));
        assert!(names.contains(&"SQRT5"));
        assert!(names.contains(&"TAU"));
        assert!(names.contains(&"VACUUM_PERMEABILITY"));
        assert!(names.contains(&"VACUUM_PERMITTIVITY"));
    }

    #[test]
    fn test_new() {
        let new_constant = Constants::new();
        let constants = new_constant.constants();
        assert!(!constants.is_empty());
    }

    #[test]
    fn test_default() {
        let default_constant = Constants::default();
        let constants = default_constant.constants();
        assert!(!constants.is_empty());
    }

    #[test]
    fn test_get_value() {
        let constants = Constants::new();

        // Test getting a float value
        let value = constants.get_value("EULER");
        assert!(value.is_some());
        if let Some(ConstantValue::Float(float_value)) = value {
            assert!((float_value - std::f64::consts::E).abs() < 1e-10);
        } else {
            panic!("Expected a float value");
        }

        // Test getting a string value
        let value = constants.get_value("HASH_ALGORITHM");
        assert!(value.is_some());
        if let Some(ConstantValue::String(string_value)) = value {
            assert_eq!(string_value, "Blake3");
        } else {
            panic!("Expected a string value");
        }

        // Test getting a u32 value
        let value = constants.get_value("HASH_COST");
        assert!(value.is_some());
        if let Some(ConstantValue::U32(u32_value)) = value {
            assert_eq!(u32_value, 8);
        } else {
            panic!("Expected a u32 value");
        }

        // Test getting a usize value
        let value = constants.get_value("HASH_LENGTH");
        assert!(value.is_some());
        if let Some(ConstantValue::Usize(usize_value)) = value {
            assert_eq!(usize_value, 32);
        } else {
            panic!("Expected a usize value");
        }

        // Test getting a char array value
        let value = constants.get_value("SPECIAL_CHARS");
        assert!(value.is_some());
        if let Some(ConstantValue::CharArray(char_array)) = value {
            assert_eq!(
                char_array,
                &[
                    '!', '@', '#', '$', '%', '^', '&', '*', '(', ')',
                    '_', '+', '=', '[', ']', '{', '}', '|', ';', ':',
                    '"', '<', '>', ',', '.', '?', '/', '~', '`'
                ]
            );
        } else {
            panic!("Expected a char array value");
        }

        // Test getting a non-existent constant value
        let value = constants.get_value("NON_EXISTENT");
        assert!(value.is_none());
    }
}