Line data    Source code

       1              : mod second;
       2              : 
       3            0 : 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            0 :     if data.len as usize != data.content.len() { return Err(()) }
       8            0 :     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            0 :                 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              : }