Add more tests and iter_values for enum_string

Author: ian-h-chamberlain

src/load_file.rs

@@ -51,7 +51,7 @@ impl Default for Modifier {
 }
 
 impl Modifier {
-    pub fn from_context(opcode: Opcode, a_mode: AddressMode, b_mode: AddressMode) -> Modifier {
+    pub fn default_88_to_94(opcode: Opcode, a_mode: AddressMode, b_mode: AddressMode) -> Modifier {
         /// Implemented based on the ICWS '94 document,
         /// section A.2.1.2: ICWS'88 to ICWS'94 Conversion
         use Opcode::*;
@@ -68,7 +68,7 @@ impl Modifier {
                     match opcode {
                         Mov | Cmp | Seq | Sne => Modifier::I,
                         Slt => Modifier::B,
-                        Add | Sub | Mul | Div | Mod => Modifier::F,
+                        Add | Sub | Mul | Div | Mod => Modifier::B,
                         _ => unreachable!(),
                     }
                 }
@@ -132,7 +132,8 @@ pub struct Instruction {
 
 impl Instruction {
     pub fn new(opcode: Opcode, field_a: Field, field_b: Field) -> Instruction {
-        let modifier = Modifier::from_context(opcode, field_a.address_mode, field_b.address_mode);
+        let modifier =
+            Modifier::default_88_to_94(opcode, field_a.address_mode, field_b.address_mode);
         Instruction {
             opcode,
             modifier,
@@ -218,19 +219,9 @@ impl PartialEq for Core {
 #[cfg(test)]
 mod tests {
     use itertools::iproduct;
-    use lazy_static::lazy_static;
-
-    use std::str::FromStr;
 
     use super::*;
 
-    lazy_static! {
-        static ref all_modes: vec::Vec<AddressMode> = ["#", "$", "@", "<", ">", "*", "{", "}"]
-            .iter()
-            .map(|mode_str| AddressMode::from_str(mode_str).unwrap())
-            .collect();
-    }
-
     #[test]
     fn default_instruction() {
         let expected_instruction = Instruction {
@@ -250,57 +241,78 @@ mod tests {
     }
 
     #[test]
-    fn dat_from_context() {
-        for (&a_mode, &b_mode) in iproduct!(all_modes.iter(), all_modes.iter()) {
+    fn dat_default_88_to_94() {
+        for (&a_mode, &b_mode) in iproduct!(AddressMode::iter_values(), AddressMode::iter_values())
+        {
             assert_eq!(
-                Modifier::from_context(Opcode::Dat, a_mode, b_mode),
+                Modifier::default_88_to_94(Opcode::Dat, a_mode, b_mode),
                 Modifier::F
             );
         }
     }
 
     #[test]
-    fn modifier_b_from_context() {
+    fn modifier_b_default_88_to_94() {
         use Opcode::*;
 
-        let opcodes = [Jmp, Jmz, Jmn, Djn, Spl, Nop];
-
-        for (&a_mode, &b_mode) in iproduct!(all_modes.iter(), all_modes.iter()) {
-            for &opcode in opcodes.iter() {
-                assert_eq!(Modifier::from_context(opcode, a_mode, b_mode), Modifier::B);
+        let opcodes = [Mov, Cmp, Seq, Sne];
+        for (&opcode, &a_mode) in iproduct!(opcodes.iter(), AddressMode::iter_values()) {
+            if a_mode != AddressMode::Immediate {
+                assert_eq!(
+                    Modifier::default_88_to_94(opcode, a_mode, AddressMode::Immediate),
+                    Modifier::B
+                );
             }
         }
 
-        let a_modes: vec::Vec<AddressMode> = ["$", "@", "<", ">", "*", "{", "}"]
-            .iter()
-            .map(|mode_str| AddressMode::from_str(mode_str).unwrap())
-            .collect();
+        let opcodes = [Add, Sub, Mul, Div, Mod];
+        for (&opcode, &a_mode, &b_mode) in iproduct!(
+            opcodes.iter(),
+            AddressMode::iter_values(),
+            AddressMode::iter_values()
+        ) {
+            if a_mode != AddressMode::Immediate {
+                assert_eq!(
+                    Modifier::default_88_to_94(opcode, a_mode, b_mode),
+                    Modifier::B
+                );
+            }
+        }
 
-        for &a_mode in a_modes.iter() {
-            for &b_mode in all_modes.iter() {
+        for (&a_mode, &b_mode) in iproduct!(AddressMode::iter_values(), AddressMode::iter_values())
+        {
+            if a_mode != AddressMode::Immediate {
                 assert_eq!(
-                    Modifier::from_context(Opcode::Slt, a_mode, b_mode),
+                    Modifier::default_88_to_94(Opcode::Slt, a_mode, b_mode),
                     Modifier::B
                 )
             }
         }
 
-        // TODO Mov, Cmp. Seq, Sne -> B
+        let opcodes = [Jmp, Jmz, Jmn, Djn, Spl, Nop];
+        for (&opcode, &a_mode, &b_mode) in iproduct!(
+            opcodes.iter(),
+            AddressMode::iter_values(),
+            AddressMode::iter_values()
+        ) {
+            assert_eq!(
+                Modifier::default_88_to_94(opcode, a_mode, b_mode),
+                Modifier::B
+            );
+        }
     }
 
     #[test]
-    fn modifier_ab_from_context() {
+    fn modifier_ab_default_88_to_94() {
         use Opcode::*;
 
         let opcodes = [Mov, Cmp, Seq, Sne, Add, Sub, Mul, Div, Mod, Slt];
 
-        for &b_mode in all_modes.iter() {
-            for &opcode in opcodes.iter() {
-                assert_eq!(
-                    Modifier::from_context(opcode, AddressMode::Immediate, b_mode),
-                    Modifier::AB
-                );
-            }
+        for (&opcode, &b_mode) in iproduct!(opcodes.iter(), AddressMode::iter_values()) {
+            assert_eq!(
+                Modifier::default_88_to_94(opcode, AddressMode::Immediate, b_mode),
+                Modifier::AB
+            );
         }
     }
 

src/parser.rs

@@ -89,7 +89,7 @@ fn parse_instruction(mut instruction_pairs: Pairs<Rule>) -> Instruction {
         .map_or_else(Field::default, parse_field);
 
     let modifier = maybe_modifier.unwrap_or_else(|| {
-        Modifier::from_context(opcode, field_a.address_mode, field_b.address_mode)
+        Modifier::default_88_to_94(opcode, field_a.address_mode, field_b.address_mode)
     });
 
     Instruction {

src/util.rs

@@ -41,6 +41,16 @@ macro_rules! enum_string {
                 }
             }
         }
+
+        impl $name {
+            #[allow(dead_code)]
+            pub fn iter_values() -> ::std::slice::Iter<'static, Self> {
+                use $name::*;
+                #[allow(unused_variable)]
+                const VALUES: &[$name] = &[$($variant,)*];
+                VALUES.iter()
+            }
+        }
     };
 }