1
mod second;
2

            
3
fn main() { println!("Hello, world!"); }
4

            
5
2
fn validate_data_simple(data: &Data) -> Result<(), ()> {
6
2
    if !data.magic.eq(&[0x13, 0x37]) { return Err(()) }
7
    if data.len as usize != data.content.len() { return Err(()) }
8
    return Ok(());
9
2
}
10

            
11
4
fn validate_data_match(data: &Data) -> i32 {
12
4
    let x: u32 = match data.content.parse::<u32>() {
13
2
        Ok(_x) => {
14
2
            let y = 2 * _x;
15
2
            if y < 6 {
16
                y
17
            } else {
18
2
                y * 2
19
            }
20
        }
21
2
        Err(_) => 0
22
    };
23
4
    if x == 0 {
24
2
        -1
25
    } else {
26
2
        (x as i32) + 1
27
    }
28
4
}
29

            
30
// https://doc.rust-lang.org/book/ch10-01-syntax.html
31
6
fn largest<T: PartialOrd>(list: &[T]) -> &T {
32
6
    let mut largest = &list[0];
33
24
    for item in list {
34
24
        if item > largest {
35
6
            largest = item;
36
18
        }
37
    }
38
6
    largest
39
6
}
40

            
41
2
fn validate_data_generics(data: &Data) {
42
2
    let number_list = vec![34, 50, 25, 100, 65];
43

            
44
2
    let result = largest(&number_list);
45
2
    println!("The largest number is {}", result);
46

            
47
2
    let char_list = vec!['y', 'm', 'a', 'q'];
48

            
49
2
    let result = largest(&char_list);
50
2
    println!("The largest char is {}", result);
51

            
52
2
    let result = largest(data.content.as_bytes());
53
2
    println!("The largest content char is {}", result);
54
2
}
55

            
56
struct Data {
57
    magic: [u8; 2],
58
    len: u8,
59
    content: String
60
}
61

            
62
#[cfg(test)]
63
mod tests {
64
    use crate::second::validate_data_panic;
65
    use crate::{Data, validate_data_generics, validate_data_match, validate_data_simple};
66

            
67
    #[test]
68
2
    fn parser_detects_errors() {
69
2
        let mut blob = Data{ magic: [0x73, 0x31], len: 2, content: "AB".parse().unwrap() };
70
2
        blob.content = blob.content + "Y";
71
2
        let result = validate_data_simple(&blob);
72
2
        assert!(result.is_err());
73
2
    }
74

            
75
    #[test]
76
2
    fn check_match() {
77
2
        let blob = Data{ magic: [0x73, 0x31], len: 2, content: "XX".parse().unwrap() };
78
2
        let x = validate_data_match(&blob);
79
2
        assert_eq!(x, -1);
80
2
    }
81

            
82
    #[test]
83
2
    fn check_match2() {
84
2
        let blob = Data{ magic: [0x73, 0x31], len: 2, content: "40".parse().unwrap() };
85
2
        let x = validate_data_match(&blob);
86
2
        assert_eq!(x, 161);
87
2
    }
88

            
89
    #[test]
90
2
    fn check_generic() {
91
2
        let blob = Data{ magic: [0x73, 0x31], len: 2, content: "QWE".parse().unwrap() };
92
2
        validate_data_generics(&blob);
93
2
    }
94

            
95
    #[test]
96
    #[should_panic]
97
2
    fn check_panic() {
98
2
        let blob = Data{ magic: [0x73, 0x31], len: 0, content: "4".parse().unwrap() };
99
2
        validate_data_panic(&blob);
100
2
    }
101

            
102
    #[test]
103
2
    fn check_not_panic() {
104
2
        let blob = Data{ magic: [0x73, 0x31], len: 2, content: "4".parse().unwrap() };
105
2
        validate_data_panic(&blob);
106
2
    }
107
}