test creation section + conversion hexa

src/simulator/mem_cmp.rs

@@ -37,8 +37,33 @@ struct Section{
     content: Vec<u8>, // la donnée en question
 }
 
+/*
+* c doit etre un caractère hexadécimale
+ */
+fn one_hex_to_dec(c: char) -> u8 {
 
+    match c {
+        'A' | 'a' => 10,
+        'B' | 'b' => 11,
+        'C' | 'c' => 12,
+        'D' | 'd' => 13,
+        'E' | 'e' => 14,
+        'F' | 'f' => 15,
+        _ => {
+             let ret : u8 = c.to_digit(10).unwrap() as u8;
+            return ret; 
+            },
+        }
+    }
 
+   
+
+fn two_hex_to_u8(c1: char, c2: char) -> u8 {
+    let a = one_hex_to_dec(c1);
+    let b = one_hex_to_dec(c2);
+
+    16*a + b
+}
 
 /*
 * Voir si instanciation d'une structure deplace les valeurs "locales" à la méthode from, je sais plus ....
@@ -49,12 +74,90 @@ impl Section{
         let addr: usize = section.addr.parse().unwrap();
         let len: usize = section.len.parse().unwrap();
 
-        /*
+        let mut tmp_a: char = ' ';
-        * Remplissage de content
+        let mut tmp_b: char = ' ';
-        */
+
+        for (i, c) in section.content.chars().enumerate(){
+
+            if i%2 == 0 {
+                tmp_a = c;
+            }
+            else {
+                tmp_b = c;
+                content.push(two_hex_to_u8(tmp_a,tmp_b));
+            }
+        }
 
 
         Section{addr:addr, len:len, content:content}
     }
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_create_section_content(){
+        let section_format = SectionFormat{
+            addr: "0".to_string(),
+            len: "0".to_string(),
+            content: "00FF0AA0A5".to_string(),
+        };
+
+        let section = Section::from(&section_format);
+        let mut expected_vec:  Vec<u8> = Vec::new();
+        expected_vec.push(0u8);
+        expected_vec.push(255u8);
+        expected_vec.push(10u8);
+        expected_vec.push(160u8);
+        expected_vec.push(165u8);
+
+        //println!("Vec from created section {:?}", &section.content);
+        //println!("Expected vec {:?}", &expected_vec);
+
+        assert_eq!(section.content, expected_vec);
+    }
+
+    #[test]
+    fn test_mod(){
+        let cond = (0%2) == 0;
+        assert_eq!(true, cond);
+    }
+
+    #[test]
+    fn test_mod_2(){
+        let cond = (1%2) == 1;
+        assert_eq!(true, cond);
+    }
+
+    #[test]
+    fn test_hex_1(){
+        let b = two_hex_to_u8('0', '0');
+        assert_eq!(0u8, b);
+    }
+
+    #[test]
+    fn test_hex_2(){
+        let b = two_hex_to_u8('F', 'F');
+        assert_eq!(255u8, b);
+    }
+
+    #[test]
+    fn test_hex_3(){
+        let b = two_hex_to_u8('0', 'A');
+        assert_eq!(10u8, b);
+    }
+
+    #[test]
+    fn test_hex_4(){
+        let b = two_hex_to_u8('A', '0');
+        assert_eq!(160u8, b);
+    }
+
+    #[test]
+    fn test_hex_5(){
+        let b = two_hex_to_u8('A', '5');
+        assert_eq!(165u8, b);
+    }
+}

src/simulator/mod.rs

@@ -1,6 +1,7 @@
 pub mod machine;
 pub mod decode;
 pub mod print;
+mod mem_cmp;
 
 
 pub mod global {