src/main.rs

Lines

93.75 %

Functions

90.91 %

Regions

91.30 %


mod second;

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

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

fn validate_data_match(data: &Data) -> i32 {
    let x: u32 = match data.content.parse::<u32>() {
        Ok(_x) => {
            let y = 2 * _x;
            if y < 6 {
                y
            } else {
                y * 2
            }
        }
        Err(_) => 0
    };
    if x == 0 {
        -1
    } else {
        (x as i32) + 1
    }
}

// https://doc.rust-lang.org/book/ch10-01-syntax.html
fn largest<T: PartialOrd>(list: &[T]) -> &T {
    let mut largest = &list[0];
    for item in list {
        if item > largest {
            largest = item;
        }
    }
    largest
}

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

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

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

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

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

struct Data {
    magic: [u8; 2],
    len: u8,
    content: String
}

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

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

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

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

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

    #[test]
    #[should_panic]
    fn check_panic() {
        let blob = Data{ magic: [0x73, 0x31], len: 0, content: "4".parse().unwrap() };
        validate_data_panic(&blob);
    }

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

Line	Count	Source (jump to first uncovered line)
1		mod second;
2
3	0	fn main() { println!("Hello, world!"); }
4
5	1	fn validate_data_simple(data: &Data) -> Result<(), ()> {
6	1	if !data.magic.eq(&[0x13, 0x37]) { return Err(()) }
7	0	if data.len as usize != data.content.len() { return Err(()) }
8	0	return Ok(());
9	1	}
10
11	2	fn validate_data_match(data: &Data) -> i32 {
12	2	let x: u32 = match data.content.parse::<u32>() {
13	1	Ok(_x) => {
14	1	let y = 2 * _x;
15	1	if y < 6 {
16	0	y
17		} else {
18	1	y * 2
19		}
20		}
21	1	Err(_) => 0
22		};
23	2	if x == 0 {
24	1	-1
25		} else {
26	1	(x as i32) + 1
27		}
28	2	}
29
30		// https://doc.rust-lang.org/book/ch10-01-syntax.html
31	3	fn largest<T: PartialOrd>(list: &[T]) -> &T {
32	3	let mut largest = &list[0];
33	3	for item in list {
34	3	if item > largest {
35	3	largest = item;
36	9	}
37		}
38	3	largest
39	3	}
40
41	1	fn validate_data_generics(data: &Data) {
42	1	let number_list = vec![34, 50, 25, 100, 65];
43
44	1	let result = largest(&number_list);
45	1	println!("The largest number is {}", result);
46
47	1	let char_list = vec!['y', 'm', 'a', 'q'];
48
49	1	let result = largest(&char_list);
50	1	println!("The largest char is {}", result);
51
52	1	let result = largest(data.content.as_bytes());
53	1	println!("The largest content char is {}", result);
54	1	}
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	1	fn parser_detects_errors() {
69	1	let mut blob = Data{ magic: [0x73, 0x31], len: 2, content: "AB".parse().unwrap() };
70	1	blob.content = blob.content + "Y";
71	1	let result = validate_data_simple(&blob);
72	1	assert!(result.is_err());
73	1	}
74
75		#[test]
76	1	fn check_match() {
77	1	let blob = Data{ magic: [0x73, 0x31], len: 2, content: "XX".parse().unwrap() };
78	1	let x = validate_data_match(&blob);
79	1	assert_eq!(x, -1);
80	1	}
81
82		#[test]
83	1	fn check_match2() {
84	1	let blob = Data{ magic: [0x73, 0x31], len: 2, content: "40".parse().unwrap() };
85	1	let x = validate_data_match(&blob);
86	1	assert_eq!(x, 161);
87	1	}
88
89		#[test]
90	1	fn check_generic() {
91	1	let blob = Data{ magic: [0x73, 0x31], len: 2, content: "QWE".parse().unwrap() };
92	1	validate_data_generics(&blob);
93	1	}
94
95		#[test]
96		#[should_panic]
97	1	fn check_panic() {
98	1	let blob = Data{ magic: [0x73, 0x31], len: 0, content: "4".parse().unwrap() };
99	1	validate_data_panic(&blob);
100	1	}
101
102		#[test]
103	1	fn check_not_panic() {
104	1	let blob = Data{ magic: [0x73, 0x31], len: 2, content: "4".parse().unwrap() };
105	1	validate_data_panic(&blob);
106	1	}
107		}