nhs-number 1.0.0

National Health Service (NHS) number for NHS England, NHS Wales, NHS Isle of Man.
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

use crate::NHSNumber;
use rand::RngExt;
use std::ops::RangeInclusive;
use std::sync::LazyLock;

/// Get the NHS Number testable range minimum value.
/// This number is valid but is never going to be issued.
///
/// Example:
///
/// ```rust
/// use nhs_number::NHSNumber;
/// use nhs_number::testable::TESTABLE_MIN;
/// let nhs_number = NHSNumber { digits: [9, 9, 9, 0, 1, 2, 3, 4, 5, 6] };
/// assert!(nhs_number >= *TESTABLE_MIN);
/// ```
///
#[allow(dead_code)]
pub static TESTABLE_MIN: LazyLock<NHSNumber> = LazyLock::new(|| NHSNumber {
    digits: [9, 9, 9, 0, 0, 0, 0, 0, 0, 0],
});

/// Get the NHS Number testable range maximum value.
/// This number is valid but is never going to be issued.
///
/// Example:
///
/// ```rust
/// use nhs_number::NHSNumber;
/// use nhs_number::testable::TESTABLE_MAX;
/// let nhs_number = NHSNumber { digits: [9, 9, 9, 0, 1, 2, 3, 4, 5, 6] };
/// assert!(nhs_number <= *TESTABLE_MAX);
/// ```
///
#[allow(dead_code)]
pub static TESTABLE_MAX: LazyLock<NHSNumber> = LazyLock::new(|| NHSNumber {
    digits: [9, 9, 9, 9, 9, 9, 9, 9, 9, 9],
});

/// Get the NHS Number testable range.
/// This range is valid but is never going to be issued.
///
/// Example:
/// ```rust
///  use nhs_number::{NHSNumber, testable::*};
/// let nhs_number = NHSNumber { digits: [9, 9, 9, 0, 1, 2, 3, 4, 5, 6] };
///  assert!(TESTABLE_RANGE_INCLUSIVE.contains(&nhs_number));
/// ```
#[allow(dead_code)]
pub static TESTABLE_RANGE_INCLUSIVE: LazyLock<RangeInclusive<NHSNumber>> =
    LazyLock::new(|| RangeInclusive::new(*TESTABLE_MIN, *TESTABLE_MAX));

/// Generate a NHS Number testable range random sample.
/// The generated number is valid but is never going to be issued.
///
/// Example:
///
/// ```rust
/// use nhs_number::{NHSNumber, testable::*};
/// let nhs_number = testable_random_sample();
/// assert!(nhs_number >= *TESTABLE_MIN);
/// assert!(nhs_number <= *TESTABLE_MAX);
/// ```
///
#[allow(dead_code)]
pub fn testable_random_sample() -> NHSNumber {
    let mut rng = rand::rng();
    NHSNumber {
        digits: [
            9,
            9,
            9,
            rng.random_range(0..=9) as i8,
            rng.random_range(0..=9) as i8,
            rng.random_range(0..=9) as i8,
            rng.random_range(0..=9) as i8,
            rng.random_range(0..=9) as i8,
            rng.random_range(0..=9) as i8,
            rng.random_range(0..=9) as i8,
        ],
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_random() {
        let a = testable_random_sample();
        assert!(a >= *TESTABLE_MIN);
        assert!(a <= *TESTABLE_MAX);
    }
}