deer 0.0.0-reserved

A backend-agnostic fail-slow deserialization framework
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

// These values use the same logic as integral, but zero is an error!

mod common;

use core::num::{
    NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI8, NonZeroIsize, NonZeroU128,
    NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize,
};

use deer::{Deserialize, Number};
use deer_desert::{assert_tokens_error, error, Token};
use serde_json::json;

macro_rules! test_zero {
    ($ty:ident) => {
        paste::paste! {
            #[test]
            fn [<$ty:lower _err_zero >]() {
                let zero = Number::from(0u8);

                assert_tokens_error::<$ty>(
                    &error! {
                        ns: "deer",
                        id: ["value"],
                        properties: {
                            "expected": $ty::reflection(),
                            "received": 0,
                            "location": []
                        }
                    },
                    &[Token::Number(zero)],
                )
            }
        }
    };

    [$($ty:ident),* $(,)?] => {
        $(test_zero!($ty);)*
    };
}

test_zero![
    NonZeroU8, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroI8, NonZeroI16, NonZeroI32, NonZeroI64,
];

#[test]
fn i128_err_zero() {
    assert_tokens_error::<NonZeroI128>(
        &error! {
            ns: "deer",
            id: ["value"],
            properties: {
                "expected": NonZeroI128::reflection(),
                "received": 0,
                "location": []
            }
        },
        &[Token::I128(0)],
    );
}

#[test]
fn isize_err_zero() {
    assert_tokens_error::<NonZeroIsize>(
        &error! {
            ns: "deer",
            id: ["value"],
            properties: {
                "expected": NonZeroIsize::reflection(),
                "received": 0,
                "location": []
            }
        },
        &[Token::ISize(0)],
    );
}

#[test]
fn u128_err_zero() {
    assert_tokens_error::<NonZeroU128>(
        &error! {
            ns: "deer",
            id: ["value"],
            properties: {
                "expected": NonZeroU128::reflection(),
                "received": 0,
                "location": []
            }
        },
        &[Token::U128(0)],
    );
}

#[test]
fn usize_err_zero() {
    assert_tokens_error::<NonZeroUsize>(
        &error! {
            ns: "deer",
            id: ["value"],
            properties: {
                "expected": NonZeroUsize::reflection(),
                "received": 0,
                "location": []
            }
        },
        &[Token::USize(0)],
    );
}