nnn 1.2.2

Generate your newtypes from a single macro.
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

/* Crate imports */
use nnn::{nnn, NNNewType as _};
/* Dependencies */
use rstest::rstest;

#[nnn(validators(exactly = 42_i32))]
struct ExactInt(i32);

#[rstest]
#[case(42_i32)]
fn valid_exact_signed_int(#[case] input: i32) {
    ExactInt::try_new(input).unwrap();
}

#[rstest]
#[case(41_i32)]
#[case(43_i32)]
fn invalid_exact_signed_int(#[case] input: i32) {
    assert!(matches!(
        ExactInt::try_new(input),
        Err(ExactIntError::Exactly)
    ));
}

#[nnn(validators(exactly = 3.00_f64))]
struct ExactFloat(f64);

#[rstest]
#[case(3.00_f64)]
fn valid_exact_float(#[case] input: f64) {
    ExactFloat::try_new(input).unwrap();
}

#[rstest]
#[case(3.01_f64)]
#[case(2.99_f64)]
fn invalid_exact_float(#[case] input: f64) {
    assert!(matches!(
        ExactFloat::try_new(input),
        Err(ExactFloatError::Exactly)
    ));
}

#[nnn(validators(exactly = (3.00_f64, 12_i32)))]
struct ExactTuple((f64, i32));

#[rstest]
#[case((3.00_f64, 12_i32))]
fn valid_exact_tuple(#[case] input: (f64, i32)) {
    ExactTuple::try_new(input).unwrap();
}

#[rstest]
#[case((3.00_f64, 13_i32))]
#[case((3.01_f64, 12_i32))]
fn invalid_exact_tuple(#[case] input: (f64, i32)) {
    assert!(matches!(
        ExactTuple::try_new(input),
        Err(ExactTupleError::Exactly)
    ));
}

#[nnn(validators(exactly = [3.00_f64, 2.00_f64]))]
struct ExactArray([f64; 2]);

#[rstest]
#[case([3.00_f64, 2.00_f64])]
fn valid_exact_array(#[case] input: [f64; 2]) {
    ExactArray::try_new(input).unwrap();
}

#[rstest]
#[case([3.00_f64, 2.01_f64])]
#[case([4.00_f64, 2.00_f64])]
fn invalid_exact_array(#[case] input: [f64; 2]) {
    assert!(matches!(
        ExactArray::try_new(input),
        Err(ExactArrayError::Exactly)
    ));
}

#[nnn(validators(exactly = "HEY"))]
struct ExactString<'str>(&'str str);

#[rstest]
#[case("HEY")]
fn valid_exact_string(#[case] input: &str) {
    ExactString::try_new(input).unwrap();
}

#[rstest]
#[case("HEY2")]
#[case("hey")]
fn invalid_exact_string(#[case] input: &'static str) {
    assert!(matches!(
        ExactString::try_new(input),
        Err(ExactStringError::Exactly)
    ));
}