test: add tests for loops

src/instructions/load.rs

@@ -23,7 +23,7 @@ impl Load for Memory {
             // TODO: this is very repetitive!
             //       Can we detect the number of arguments and do this automatically?
             match ins {
-                I::LoadString(v) | I::Store(v) | I::Load(v) | I::JumpNotZero(v) | I::JumpZero(v) | I::Jump(v) | I::Push(v) | I::EndLoop(v) => write(v),
+                I::LoadString(v) | I::Store(v) | I::Load(v) | I::JumpNotZero(v) | I::JumpZero(v) | I::Jump(v) | I::Push(v) => write(v),
                 _ => {}
             }
         }

src/instructions/mod.rs

@@ -42,9 +42,6 @@ pub enum Instruction {
     Mul,
     Div,
 
-    StartLoop,
-    EndLoop(u16),
-
     /// Jump to the address.
     Jump(u16),
 
@@ -93,7 +90,6 @@ impl From<Instruction> for u16 {
     fn from(ins: Instruction) -> Self {
         let v = match ins {
             I::Push(_) => I::Push(0),
-            I::EndLoop(_) => I::EndLoop(0),
             I::Jump(_) => I::Jump(0),
             I::JumpZero(_) => I::JumpZero(0),
             I::JumpNotZero(_) => I::JumpNotZero(0),

src/machine/decode.rs

@@ -35,7 +35,6 @@ impl Decode for Machine {
         //       Can we detect the number of arguments and do this automatically?
         match i {
             I::Push(_) => I::Push(self.arg()),
-            I::EndLoop(_) => I::EndLoop(self.arg()),
             I::Jump(_) => I::Jump(self.arg()),
             I::JumpZero(_) => I::JumpZero(self.arg()),
             I::JumpNotZero(_) => I::JumpNotZero(self.arg()),

src/machine/execute.rs

@@ -61,9 +61,6 @@ impl Execute for Machine {
             I::GreaterThan => s.apply_two(|a, b| (a > b).into()),
             I::GreaterThanOrEqual => s.apply_two(|a, b| (a >= b).into()),
 
-            I::StartLoop => {}
-
-            I::EndLoop(start) => self.reg.set(PC, start),
             I::Jump(addr) => self.reg.set(PC, addr),
 
             I::JumpZero(addr) => {

tests/hello_world.rs

@@ -3,7 +3,7 @@ mod tests {
     extern crate opcodes_to_algorithms as O;
 
     use mockall::{automock, predicate::*};
-    use O::{Machine as M, Execute, Instruction as I, Load, WithStringManager};
+    use O::{Machine, Execute, Instruction as I, Load, WithStringManager};
 
     #[cfg_attr(test, automock)]
     trait Printer {
@@ -12,7 +12,7 @@ mod tests {
 
     #[test]
     fn test_print_hello_world() {
-        let mut m = M::new();
+        let mut m = Machine::new();
 
         let mut ms = m.mem.string();
         let h_addr = ms.add_str("hello, ");

tests/loop.rs

@@ -2,8 +2,31 @@
 mod loop_tests {
     extern crate opcodes_to_algorithms as O;
 
-    // use O::{Machine as M, Execute, Instruction as I};
+    use O::{Machine, Execute, Load, Instruction as I};
 
     #[test]
-    fn test_loop() {}
-}
+    fn test_loop() {
+        let mut m = Machine::new();
+
+        let loop_start = 1;
+
+        m.mem.load_code(vec![
+            I::Push(0),  // i = 0
+
+            // [loop_start]
+            I::Push(2),
+            I::Add,      // i += 2
+            I::Dup,      // B = i
+            I::Push(20), // A = 20
+
+            // [A = 20, B = i; A < B; ? 1 : 0]
+            I::LessThan,
+            I::JumpZero(loop_start), // 20 , jump to loop_start
+            I::Push(0xFF),
+        ]);
+
+        m.run();
+
+        assert_eq!(m.mem.read_stack(2), [22, 255]);
+    }
+}

tests/strings.rs

@@ -2,11 +2,11 @@
 mod tests {
     extern crate opcodes_to_algorithms as O;
 
-    use O::{Machine as M, Execute, Instruction as I, Load, WithStringManager};
+    use O::{Machine, Execute, Instruction as I, Load, WithStringManager};
 
     #[test]
     fn test_load_str() {
-        let mut m = M::new();
+        let mut m = Machine::new();
         let mut ms = m.mem.string();
 
         let s = "hello";