mesh-loader 0.0.1

Fast parser for 3D-model-formats.
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

use super::*;

#[test]
fn max_digit_count() {
    macro_rules! max_digit_count {
        ($ty:ident) => {{
            let mut max = $ty::MAX;
            let mut count = 0;
            while max > 0 {
                count += 1;
                max /= 10;
            }
            assert_eq!(<$ty as Int>::MAX_DIGIT_COUNT, count);
            count
        }};
    }

    assert_eq!(max_digit_count!(u128), 39);
    assert_eq!(max_digit_count!(u64), 20);
    assert_eq!(max_digit_count!(u32), 10);
    assert_eq!(max_digit_count!(u16), 5);
    assert_eq!(max_digit_count!(u8), 3);
    // assert_eq!(max_digit_count!(i128), 39);
    // assert_eq!(max_digit_count!(i64), 19);
    // assert_eq!(max_digit_count!(i32), 10);
    // assert_eq!(max_digit_count!(i16), 5);
    // assert_eq!(max_digit_count!(i8), 3);
}

#[test]
fn uint() {
    assert_eq!(
        u128::parse_partial(u128::MAX.to_string().as_bytes())
            .unwrap()
            .0,
        u128::MAX
    );
    assert_eq!(
        u128::parse_partial(i128::MAX.to_string().as_bytes())
            .unwrap()
            .0,
        i128::MAX as _
    );
    assert_eq!(
        u64::parse_partial(u64::MAX.to_string().as_bytes())
            .unwrap()
            .0,
        u64::MAX
    );
    assert_eq!(
        u64::parse_partial(10000000000000000000u64.to_string().as_bytes())
            .unwrap()
            .0,
        10000000000000000000u64
    );
    assert_eq!(
        u64::parse_partial(9999999999999999999u64.to_string().as_bytes())
            .unwrap()
            .0,
        9999999999999999999u64
    );
    assert_eq!(
        u64::parse_partial(i64::MAX.to_string().as_bytes())
            .unwrap()
            .0,
        i64::MAX as u64
    );
    assert_eq!(
        u32::parse_partial(u32::MAX.to_string().as_bytes())
            .unwrap()
            .0,
        u32::MAX
    );
    assert_eq!(
        u32::parse_partial(i32::MAX.to_string().as_bytes())
            .unwrap()
            .0,
        i32::MAX as u32
    );
    assert_eq!(
        u16::parse_partial(u16::MAX.to_string().as_bytes())
            .unwrap()
            .0,
        u16::MAX
    );
    assert_eq!(
        u16::parse_partial(i16::MAX.to_string().as_bytes())
            .unwrap()
            .0,
        i16::MAX as u16
    );
    assert_eq!(
        u8::parse_partial(u8::MAX.to_string().as_bytes()).unwrap().0,
        u8::MAX
    );
    assert_eq!(
        u8::parse_partial(i8::MAX.to_string().as_bytes()).unwrap().0,
        i8::MAX as u8
    );
}