sscanf 0.5.0

A sscanf (inverse of format!()) macro with near unlimited parsing capabilities
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

use sscanf::*;

// TODO: lifetime tests (static, "input")

static CORRECT_INPUT: &str = "Testing with (3.4,1,-2,0)!";
macro_rules! correct_result {
    (named) => {
        TestStruct {
            a: 0,
            b: String::from("1"),
            c: -2,
            d: 3.4,
        }
    };
    (unnamed) => {
        TestStruct(0, String::from("1"), -2, 3.4)
    };
}

static WRONG_INPUTS: &[&str] = &[
    "Testing with (3.4,1,-2)!",
    "Testing with (3.-4,1,-2,0)!",
    "Testing with (3.4,,-2,0)!",
    "Testing with (3.4,1,,0)!",
    "Testing with (3.4,1,+-2,0)!",
    "Testing with (3.4,1,-2,1000)!",
];

#[test]
fn basic() {
    #[derive(FromScanf, Debug, PartialEq)]
    #[sscanf(format = "({d},{b},{c},{a})")]
    struct TestStruct {
        a: u8,
        b: String,
        c: isize,
        d: f32,
    }

    let ret = sscanf!(CORRECT_INPUT, "Testing with {TestStruct}!").unwrap();
    assert_eq!(ret, correct_result!(named));

    for input in WRONG_INPUTS {
        assert!(sscanf!(input, "Testing with {TestStruct}!").is_none());
    }
}

#[test]
fn indexed() {
    #[derive(FromScanf, Debug, PartialEq)]
    #[sscanf(format = "({3},{1},{2},{0})")]
    struct TestStruct {
        a: u8,
        b: String,
        c: isize,
        d: f32,
    }

    let ret = sscanf!(CORRECT_INPUT, "Testing with {TestStruct}!").unwrap();
    assert_eq!(ret, correct_result!(named));

    for input in WRONG_INPUTS {
        assert!(sscanf!(input, "Testing with {TestStruct}!").is_none());
    }
}

#[test]
fn auto_indexed() {
    #[derive(FromScanf, Debug, PartialEq)]
    #[sscanf(format = "({},{},{},{})")]
    struct TestStruct {
        d: f32,
        b: String,
        c: isize,
        a: u8,
    }

    let ret = sscanf!(CORRECT_INPUT, "Testing with {TestStruct}!").unwrap();
    assert_eq!(ret, correct_result!(named));

    for input in WRONG_INPUTS {
        assert!(sscanf!(input, "Testing with {TestStruct}!").is_none());
    }
}

#[test]
fn tuple_struct() {
    #[derive(FromScanf, Debug, PartialEq)]
    #[sscanf(format = "({3},{1},{2},{0})")]
    struct TestStruct(u8, String, isize, f32);

    let ret = sscanf!(CORRECT_INPUT, "Testing with {TestStruct}!").unwrap();
    assert_eq!(ret, correct_result!(unnamed));

    for input in WRONG_INPUTS {
        assert!(sscanf!(input, "Testing with {TestStruct}!").is_none());
    }
}

#[test]
fn transparent() {
    #[derive(FromScanf, Debug, PartialEq)]
    #[sscanf(transparent)]
    struct TestStructTuple(usize);

    let ret = sscanf!("5", "{TestStructTuple}").unwrap();
    assert_eq!(ret, TestStructTuple(5));

    #[derive(FromScanf, Debug, PartialEq)]
    #[sscanf(transparent)]
    struct TestStructNamed {
        a: usize,
    }

    let ret = sscanf!("5", "{TestStructNamed}").unwrap();
    assert_eq!(ret, TestStructNamed { a: 5 });
}