diff --git a/README.md b/README.md
index b49e1ba..6bd5c87 100644
--- a/README.md
+++ b/README.md
@@ -33,6 +33,6 @@ run at once, there is currently not a way to run them individually.
 The blackbox test script executes the programs in the test_programs/ directory
 and verifies their output against known expected output.
 + Make sure the main executable has been built (see above)
-+ Run the 'blackbox_test.py' python script via `python blackbox_test.py` or
-`./blackbox_test.py`
++ Run the 'test_programs.py' python script via `python test_programs.py` or
+`./test_programs.py`
     + This won't work on Windows currently
\ No newline at end of file
diff --git a/src/instructions/instruction_exec.c b/src/instructions/instruction_exec.c
index 2af6c18..86ff82f 100644
--- a/src/instructions/instruction_exec.c
+++ b/src/instructions/instruction_exec.c
@@ -54,6 +54,8 @@ int exec_instr(struct instruction ic)
             instr_exit();
 
             return 1;
+        case INSTR_NOOP:
+            return 0;
         case INSTR_LOAD:
             instr_load(ic);
             break;
diff --git a/src/instructions/instructions.c b/src/instructions/instructions.c
index 29a9650..f07f84e 100644
--- a/src/instructions/instructions.c
+++ b/src/instructions/instructions.c
@@ -37,74 +37,74 @@ void instr_load(struct instruction ic)
 
     switch (ic.mode)
     {
-    case MODE_IMMEDIATE_B:
-        *dr = ic.d2;
-        break;
-    case MODE_IMMEDIATE_W:
-        *dr = ic.data;
-        break;
-    case MODE_DATA_32:
-        *dr = get_dword(ram, incr_pc());
-        break;
-    case MODE_DATA_32_ADDR:
-        mem_addr = get_dword(ram, incr_pc());
-        *dr = get_dword(ram, mem_addr);
-        break;
-    case MODE_DATA_32_ADDR_W:
-        mem_addr = get_dword(ram, incr_pc());
-        *dr = get_word(ram, mem_addr);
-        break;
-    case MODE_DATA_32_ADDR_B:
-        mem_addr = get_dword(ram, incr_pc());
-        *dr = get_byte(ram, mem_addr);
-        break;
-    case MODE_DATA_32_INDR:
-        mem_addr = get_dword(ram, incr_pc());
-        mem_addr = get_dword(ram, mem_addr);
-        *dr = get_dword(ram, mem_addr);
-        break;
-    case MODE_DATA_32_INDR_W:
-        mem_addr = get_dword(ram, incr_pc());
-        mem_addr = get_dword(ram, mem_addr);
-        *dr = get_word(ram, mem_addr);
-        break;
-    case MODE_DATA_32_INDR_B:
-        mem_addr = get_dword(ram, incr_pc());
-        mem_addr = get_dword(ram, mem_addr);
-        *dr = get_byte(ram, mem_addr);
-        break;
-    case MODE_REGISTER:
-        *dr = r[ic.d2];
-        break;
-    case MODE_REGISTER_ADDR:
-        mem_addr = r[ic.d2];
-        *dr = get_dword(ram, mem_addr);
-        break;
-    case MODE_REGISTER_ADDR_W:
-        mem_addr = r[ic.d2];
-        *dr = get_word(ram, mem_addr);
-        break;
-    case MODE_REGISTER_ADDR_B:
-        mem_addr = r[ic.d2];
-        *dr = get_byte(ram, mem_addr);
-        break;
-    case MODE_REGISTER_INDR:
-        mem_addr = r[ic.d2];
-        mem_addr = get_dword(ram, mem_addr);
-        *dr = get_dword(ram, mem_addr);
-        break;
-    case MODE_REGISTER_INDR_W:
-        mem_addr = r[ic.d2];
-        mem_addr = get_dword(ram, mem_addr);
-        *dr = get_word(ram, mem_addr);
-        break;
-    case MODE_REGISTER_INDR_B:
-        mem_addr = r[ic.d2];
-        mem_addr = get_dword(ram, mem_addr);
-        *dr = get_byte(ram, mem_addr);
-        break;
-    default:
-        unsupported_mode(ic.mode);
+        case MODE_IMMEDIATE_B:
+            *dr = ic.d2;
+            break;
+        case MODE_IMMEDIATE_W:
+            *dr = ic.data;
+            break;
+        case MODE_DATA_32:
+            *dr = get_dword(ram, incr_pc());
+            break;
+        case MODE_DATA_32_ADDR:
+            mem_addr = get_dword(ram, incr_pc());
+            *dr = get_dword(ram, mem_addr);
+            break;
+        case MODE_DATA_32_ADDR_W:
+            mem_addr = get_dword(ram, incr_pc());
+            *dr = get_word(ram, mem_addr);
+            break;
+        case MODE_DATA_32_ADDR_B:
+            mem_addr = get_dword(ram, incr_pc());
+            *dr = get_byte(ram, mem_addr);
+            break;
+        case MODE_DATA_32_INDR:
+            mem_addr = get_dword(ram, incr_pc());
+            mem_addr = get_dword(ram, mem_addr);
+            *dr = get_dword(ram, mem_addr);
+            break;
+        case MODE_DATA_32_INDR_W:
+            mem_addr = get_dword(ram, incr_pc());
+            mem_addr = get_dword(ram, mem_addr);
+            *dr = get_word(ram, mem_addr);
+            break;
+        case MODE_DATA_32_INDR_B:
+            mem_addr = get_dword(ram, incr_pc());
+            mem_addr = get_dword(ram, mem_addr);
+            *dr = get_byte(ram, mem_addr);
+            break;
+        case MODE_REGISTER:
+            *dr = r[ic.d2];
+            break;
+        case MODE_REGISTER_ADDR:
+            mem_addr = r[ic.d2];
+            *dr = get_dword(ram, mem_addr);
+            break;
+        case MODE_REGISTER_ADDR_W:
+            mem_addr = r[ic.d2];
+            *dr = get_word(ram, mem_addr);
+            break;
+        case MODE_REGISTER_ADDR_B:
+            mem_addr = r[ic.d2];
+            *dr = get_byte(ram, mem_addr);
+            break;
+        case MODE_REGISTER_INDR:
+            mem_addr = r[ic.d2];
+            mem_addr = get_dword(ram, mem_addr);
+            *dr = get_dword(ram, mem_addr);
+            break;
+        case MODE_REGISTER_INDR_W:
+            mem_addr = r[ic.d2];
+            mem_addr = get_dword(ram, mem_addr);
+            *dr = get_word(ram, mem_addr);
+            break;
+        case MODE_REGISTER_INDR_B:
+            mem_addr = r[ic.d2];
+            mem_addr = get_dword(ram, mem_addr);
+            *dr = get_byte(ram, mem_addr);
+            break;
+        default:
+            unsupported_mode(ic.mode);
     }
 
     alter_sr();
@@ -122,65 +122,65 @@ void instr_store(struct instruction ic)
 
     switch (ic.mode)
     {
-    case MODE_DATA_32_ADDR:
-        mem_addr = get_dword(ram, incr_pc());
-        store_dword(ram, mem_addr, *dr);
-        break;
-    case MODE_DATA_32_ADDR_W:
-        mem_addr = get_dword(ram, incr_pc());
-        store_word(ram, mem_addr, *dr);
-        break;
-    case MODE_DATA_32_ADDR_B:
-        mem_addr = get_dword(ram, incr_pc());
-        store_byte(ram, mem_addr, *dr);
-        break;
-    case MODE_DATA_32_INDR:
-        mem_addr = get_dword(ram, incr_pc());
-        mem_addr = get_dword(ram, mem_addr);
-        store_dword(ram, mem_addr, *dr);
-        break;
-    case MODE_DATA_32_INDR_W:
-        mem_addr = get_dword(ram, incr_pc());
-        mem_addr = get_dword(ram, mem_addr);
-        store_word(ram, mem_addr, *dr);
-        break;
-    case MODE_DATA_32_INDR_B:
-        mem_addr = get_dword(ram, incr_pc());
-        mem_addr = get_dword(ram, mem_addr);
-        store_byte(ram, mem_addr, *dr);
-        break;
-    case MODE_REGISTER:
-        r[ic.d2] = *dr;
-        break;
-    case MODE_REGISTER_ADDR:
-        mem_addr = r[ic.d2];
-        store_dword(ram, mem_addr, *dr);
-        break;
-    case MODE_REGISTER_ADDR_W:
-        mem_addr = r[ic.d2];
-        store_word(ram, mem_addr, *dr);
-        break;
-    case MODE_REGISTER_ADDR_B:
-        mem_addr = r[ic.d2];
-        store_byte(ram, mem_addr, *dr);
-        break;
-    case MODE_REGISTER_INDR:
-        mem_addr = r[ic.d2];
-        mem_addr = get_dword(ram, mem_addr);
-        store_dword(ram, mem_addr, *dr);
-        break;
-    case MODE_REGISTER_INDR_W:
-        mem_addr = r[ic.d2];
-        mem_addr = get_dword(ram, mem_addr);
-        store_word(ram, mem_addr, *dr);
-        break;
-    case MODE_REGISTER_INDR_B:
-        mem_addr = r[ic.d2];
-        mem_addr = get_dword(ram, mem_addr);
-        store_byte(ram, mem_addr, *dr);
-        break;
-    default:
-        unsupported_mode(ic.mode);
+        case MODE_DATA_32_ADDR:
+            mem_addr = get_dword(ram, incr_pc());
+            store_dword(ram, mem_addr, *dr);
+            break;
+        case MODE_DATA_32_ADDR_W:
+            mem_addr = get_dword(ram, incr_pc());
+            store_word(ram, mem_addr, *dr);
+            break;
+        case MODE_DATA_32_ADDR_B:
+            mem_addr = get_dword(ram, incr_pc());
+            store_byte(ram, mem_addr, *dr);
+            break;
+        case MODE_DATA_32_INDR:
+            mem_addr = get_dword(ram, incr_pc());
+            mem_addr = get_dword(ram, mem_addr);
+            store_dword(ram, mem_addr, *dr);
+            break;
+        case MODE_DATA_32_INDR_W:
+            mem_addr = get_dword(ram, incr_pc());
+            mem_addr = get_dword(ram, mem_addr);
+            store_word(ram, mem_addr, *dr);
+            break;
+        case MODE_DATA_32_INDR_B:
+            mem_addr = get_dword(ram, incr_pc());
+            mem_addr = get_dword(ram, mem_addr);
+            store_byte(ram, mem_addr, *dr);
+            break;
+        case MODE_REGISTER:
+            r[ic.d2] = *dr;
+            break;
+        case MODE_REGISTER_ADDR:
+            mem_addr = r[ic.d2];
+            store_dword(ram, mem_addr, *dr);
+            break;
+        case MODE_REGISTER_ADDR_W:
+            mem_addr = r[ic.d2];
+            store_word(ram, mem_addr, *dr);
+            break;
+        case MODE_REGISTER_ADDR_B:
+            mem_addr = r[ic.d2];
+            store_byte(ram, mem_addr, *dr);
+            break;
+        case MODE_REGISTER_INDR:
+            mem_addr = r[ic.d2];
+            mem_addr = get_dword(ram, mem_addr);
+            store_dword(ram, mem_addr, *dr);
+            break;
+        case MODE_REGISTER_INDR_W:
+            mem_addr = r[ic.d2];
+            mem_addr = get_dword(ram, mem_addr);
+            store_word(ram, mem_addr, *dr);
+            break;
+        case MODE_REGISTER_INDR_B:
+            mem_addr = r[ic.d2];
+            mem_addr = get_dword(ram, mem_addr);
+            store_byte(ram, mem_addr, *dr);
+            break;
+        default:
+            unsupported_mode(ic.mode);
     }
 
     alter_sr();
@@ -198,74 +198,74 @@ void instr_add(struct instruction ic)
 
     switch (ic.mode)
     {
-    case MODE_IMMEDIATE_B:
-        *dr += ic.d2;
-        break;
-    case MODE_IMMEDIATE_W:
-        *dr += ic.data;
-        break;
-    case MODE_DATA_32:
-        *dr += get_dword(ram, incr_pc());
-        break;
-    case MODE_DATA_32_ADDR:
-        mem_addr = get_dword(ram, incr_pc());
-        *dr += get_dword(ram, mem_addr);
-        break;
-    case MODE_DATA_32_ADDR_W:
-        mem_addr = get_dword(ram, incr_pc());
-        *dr += get_word(ram, mem_addr);
-        break;
-    case MODE_DATA_32_ADDR_B:
-        mem_addr = get_dword(ram, incr_pc());
-        *dr += get_byte(ram, mem_addr);
-        break;
-    case MODE_DATA_32_INDR:
-        mem_addr = get_dword(ram, incr_pc());
-        mem_addr = get_dword(ram, mem_addr);
-        *dr += get_dword(ram, mem_addr);
-        break;
-    case MODE_DATA_32_INDR_W:
-        mem_addr = get_dword(ram, incr_pc());
-        mem_addr = get_dword(ram, mem_addr);
-        *dr += get_word(ram, mem_addr);
-        break;
-    case MODE_DATA_32_INDR_B:
-        mem_addr = get_dword(ram, incr_pc());
-        mem_addr = get_dword(ram, mem_addr);
-        *dr += get_byte(ram, mem_addr);
-        break;
-    case MODE_REGISTER:
-        *dr += r[ic.d2];
-        break;
-    case MODE_REGISTER_ADDR:
-        mem_addr = r[ic.d2];
-        *dr += get_dword(ram, mem_addr);
-        break;
-    case MODE_REGISTER_ADDR_W:
-        mem_addr = r[ic.d2];
-        *dr += get_word(ram, mem_addr);
-        break;
-    case MODE_REGISTER_ADDR_B:
-        mem_addr = r[ic.d2];
-        *dr += get_byte(ram, mem_addr);
-        break;
-    case MODE_REGISTER_INDR:
-        mem_addr = r[ic.d2];
-        mem_addr = get_dword(ram, mem_addr);
-        *dr += get_dword(ram, mem_addr);
-        break;
-    case MODE_REGISTER_INDR_W:
-        mem_addr = r[ic.d2];
-        mem_addr = get_dword(ram, mem_addr);
-        *dr += get_word(ram, mem_addr);
-        break;
-    case MODE_REGISTER_INDR_B:
-        mem_addr = r[ic.d2];
-        mem_addr = get_dword(ram, mem_addr);
-        *dr += get_byte(ram, mem_addr);
-        break;
-    default:
-        unsupported_mode(ic.mode);
+        case MODE_IMMEDIATE_B:
+            *dr += ic.d2;
+            break;
+        case MODE_IMMEDIATE_W:
+            *dr += ic.data;
+            break;
+        case MODE_DATA_32:
+            *dr += get_dword(ram, incr_pc());
+            break;
+        case MODE_DATA_32_ADDR:
+            mem_addr = get_dword(ram, incr_pc());
+            *dr += get_dword(ram, mem_addr);
+            break;
+        case MODE_DATA_32_ADDR_W:
+            mem_addr = get_dword(ram, incr_pc());
+            *dr += get_word(ram, mem_addr);
+            break;
+        case MODE_DATA_32_ADDR_B:
+            mem_addr = get_dword(ram, incr_pc());
+            *dr += get_byte(ram, mem_addr);
+            break;
+        case MODE_DATA_32_INDR:
+            mem_addr = get_dword(ram, incr_pc());
+            mem_addr = get_dword(ram, mem_addr);
+            *dr += get_dword(ram, mem_addr);
+            break;
+        case MODE_DATA_32_INDR_W:
+            mem_addr = get_dword(ram, incr_pc());
+            mem_addr = get_dword(ram, mem_addr);
+            *dr += get_word(ram, mem_addr);
+            break;
+        case MODE_DATA_32_INDR_B:
+            mem_addr = get_dword(ram, incr_pc());
+            mem_addr = get_dword(ram, mem_addr);
+            *dr += get_byte(ram, mem_addr);
+            break;
+        case MODE_REGISTER:
+            *dr += r[ic.d2];
+            break;
+        case MODE_REGISTER_ADDR:
+            mem_addr = r[ic.d2];
+            *dr += get_dword(ram, mem_addr);
+            break;
+        case MODE_REGISTER_ADDR_W:
+            mem_addr = r[ic.d2];
+            *dr += get_word(ram, mem_addr);
+            break;
+        case MODE_REGISTER_ADDR_B:
+            mem_addr = r[ic.d2];
+            *dr += get_byte(ram, mem_addr);
+            break;
+        case MODE_REGISTER_INDR:
+            mem_addr = r[ic.d2];
+            mem_addr = get_dword(ram, mem_addr);
+            *dr += get_dword(ram, mem_addr);
+            break;
+        case MODE_REGISTER_INDR_W:
+            mem_addr = r[ic.d2];
+            mem_addr = get_dword(ram, mem_addr);
+            *dr += get_word(ram, mem_addr);
+            break;
+        case MODE_REGISTER_INDR_B:
+            mem_addr = r[ic.d2];
+            mem_addr = get_dword(ram, mem_addr);
+            *dr += get_byte(ram, mem_addr);
+            break;
+        default:
+            unsupported_mode(ic.mode);
     }
 
     alter_sr();
@@ -283,74 +283,74 @@ void instr_sub(struct instruction ic)
 
     switch (ic.mode)
     {
-    case MODE_IMMEDIATE_B:
-        *dr -= ic.d2;
-        break;
-    case MODE_IMMEDIATE_W:
-        *dr -= ic.data;
-        break;
-    case MODE_DATA_32:
-        *dr -= get_dword(ram, incr_pc());
-        break;
-    case MODE_DATA_32_ADDR:
-        mem_addr = get_dword(ram, incr_pc());
-        *dr -= get_dword(ram, mem_addr);
-        break;
-    case MODE_DATA_32_ADDR_W:
-        mem_addr = get_dword(ram, incr_pc());
-        *dr -= get_word(ram, mem_addr);
-        break;
-    case MODE_DATA_32_ADDR_B:
-        mem_addr = get_dword(ram, incr_pc());
-        *dr -= get_byte(ram, mem_addr);
-        break;
-    case MODE_DATA_32_INDR:
-        mem_addr = get_dword(ram, incr_pc());
-        mem_addr = get_dword(ram, mem_addr);
-        *dr -= get_dword(ram, mem_addr);
-        break;
-    case MODE_DATA_32_INDR_W:
-        mem_addr = get_dword(ram, incr_pc());
-        mem_addr = get_dword(ram, mem_addr);
-        *dr -= get_word(ram, mem_addr);
-        break;
-    case MODE_DATA_32_INDR_B:
-        mem_addr = get_dword(ram, incr_pc());
-        mem_addr = get_dword(ram, mem_addr);
-        *dr -= get_byte(ram, mem_addr);
-        break;
-    case MODE_REGISTER:
-        *dr -= r[ic.d2];
-        break;
-    case MODE_REGISTER_ADDR:
-        mem_addr = r[ic.d2];
-        *dr -= get_dword(ram, mem_addr);
-        break;
-    case MODE_REGISTER_ADDR_W:
-        mem_addr = r[ic.d2];
-        *dr -= get_word(ram, mem_addr);
-        break;
-    case MODE_REGISTER_ADDR_B:
-        mem_addr = r[ic.d2];
-        *dr -= get_byte(ram, mem_addr);
-        break;
-    case MODE_REGISTER_INDR:
-        mem_addr = r[ic.d2];
-        mem_addr = get_dword(ram, mem_addr);
-        *dr -= get_dword(ram, mem_addr);
-        break;
-    case MODE_REGISTER_INDR_W:
-        mem_addr = r[ic.d2];
-        mem_addr = get_dword(ram, mem_addr);
-        *dr -= get_word(ram, mem_addr);
-        break;
-    case MODE_REGISTER_INDR_B:
-        mem_addr = r[ic.d2];
-        mem_addr = get_dword(ram, mem_addr);
-        *dr -= get_byte(ram, mem_addr);
-        break;
-    default:
-        unsupported_mode(ic.mode);
+        case MODE_IMMEDIATE_B:
+            *dr -= ic.d2;
+            break;
+        case MODE_IMMEDIATE_W:
+            *dr -= ic.data;
+            break;
+        case MODE_DATA_32:
+            *dr -= get_dword(ram, incr_pc());
+            break;
+        case MODE_DATA_32_ADDR:
+            mem_addr = get_dword(ram, incr_pc());
+            *dr -= get_dword(ram, mem_addr);
+            break;
+        case MODE_DATA_32_ADDR_W:
+            mem_addr = get_dword(ram, incr_pc());
+            *dr -= get_word(ram, mem_addr);
+            break;
+        case MODE_DATA_32_ADDR_B:
+            mem_addr = get_dword(ram, incr_pc());
+            *dr -= get_byte(ram, mem_addr);
+            break;
+        case MODE_DATA_32_INDR:
+            mem_addr = get_dword(ram, incr_pc());
+            mem_addr = get_dword(ram, mem_addr);
+            *dr -= get_dword(ram, mem_addr);
+            break;
+        case MODE_DATA_32_INDR_W:
+            mem_addr = get_dword(ram, incr_pc());
+            mem_addr = get_dword(ram, mem_addr);
+            *dr -= get_word(ram, mem_addr);
+            break;
+        case MODE_DATA_32_INDR_B:
+            mem_addr = get_dword(ram, incr_pc());
+            mem_addr = get_dword(ram, mem_addr);
+            *dr -= get_byte(ram, mem_addr);
+            break;
+        case MODE_REGISTER:
+            *dr -= r[ic.d2];
+            break;
+        case MODE_REGISTER_ADDR:
+            mem_addr = r[ic.d2];
+            *dr -= get_dword(ram, mem_addr);
+            break;
+        case MODE_REGISTER_ADDR_W:
+            mem_addr = r[ic.d2];
+            *dr -= get_word(ram, mem_addr);
+            break;
+        case MODE_REGISTER_ADDR_B:
+            mem_addr = r[ic.d2];
+            *dr -= get_byte(ram, mem_addr);
+            break;
+        case MODE_REGISTER_INDR:
+            mem_addr = r[ic.d2];
+            mem_addr = get_dword(ram, mem_addr);
+            *dr -= get_dword(ram, mem_addr);
+            break;
+        case MODE_REGISTER_INDR_W:
+            mem_addr = r[ic.d2];
+            mem_addr = get_dword(ram, mem_addr);
+            *dr -= get_word(ram, mem_addr);
+            break;
+        case MODE_REGISTER_INDR_B:
+            mem_addr = r[ic.d2];
+            mem_addr = get_dword(ram, mem_addr);
+            *dr -= get_byte(ram, mem_addr);
+            break;
+        default:
+            unsupported_mode(ic.mode);
     }
 
     alter_sr();
@@ -368,74 +368,74 @@ void instr_push(struct instruction ic)
 
     switch (ic.mode)
     {
-    case MODE_IMMEDIATE_B:
-        push(ic.d2);
-        break;
-    case MODE_IMMEDIATE_W:
-        push(ic.data);
-        break;
-    case MODE_DATA_32:
-        push(get_dword(ram, incr_pc()));
-        break;
-    case MODE_DATA_32_ADDR:
-        mem_addr = get_dword(ram, incr_pc());
-        push(get_dword(ram, mem_addr));
-        break;
-    case MODE_DATA_32_ADDR_W:
-        mem_addr = get_dword(ram, incr_pc());
-        push(get_word(ram, mem_addr));
-        break;
-    case MODE_DATA_32_ADDR_B:
-        mem_addr = get_dword(ram, incr_pc());
-        push(get_byte(ram, mem_addr));
-        break;
-    case MODE_DATA_32_INDR:
-        mem_addr = get_dword(ram, incr_pc());
-        mem_addr = get_dword(ram, mem_addr);
-        push(get_dword(ram, mem_addr));
-        break;
-    case MODE_DATA_32_INDR_W:
-        mem_addr = get_dword(ram, incr_pc());
-        mem_addr = get_dword(ram, mem_addr);
-        push(get_word(ram, mem_addr));
-        break;
-    case MODE_DATA_32_INDR_B:
-        mem_addr = get_dword(ram, incr_pc());
-        mem_addr = get_dword(ram, mem_addr);
-        push(get_byte(ram, mem_addr));
-        break;
-    case MODE_REGISTER:
-        push(r[ic.d2]);
-        break;
-    case MODE_REGISTER_ADDR:
-        mem_addr = r[ic.d2];
-        push(get_dword(ram, mem_addr));
-        break;
-    case MODE_REGISTER_ADDR_W:
-        mem_addr = r[ic.d2];
-        push(get_word(ram, mem_addr));
-        break;
-    case MODE_REGISTER_ADDR_B:
-        mem_addr = r[ic.d2];
-        push(get_byte(ram, mem_addr));
-        break;
-    case MODE_REGISTER_INDR:
-        mem_addr = r[ic.d2];
-        mem_addr = get_dword(ram, mem_addr);
-        push(get_dword(ram, mem_addr));
-        break;
-    case MODE_REGISTER_INDR_W:
-        mem_addr = r[ic.d2];
-        mem_addr = get_dword(ram, mem_addr);
-        push(get_word(ram, mem_addr));
-        break;
-    case MODE_REGISTER_INDR_B:
-        mem_addr = r[ic.d2];
-        mem_addr = get_dword(ram, mem_addr);
-        push(get_byte(ram, mem_addr));
-        break;
-    default:
-        unsupported_mode(ic.mode);
+        case MODE_IMMEDIATE_B:
+            push(ic.d2);
+            break;
+        case MODE_IMMEDIATE_W:
+            push(ic.data);
+            break;
+        case MODE_DATA_32:
+            push(get_dword(ram, incr_pc()));
+            break;
+        case MODE_DATA_32_ADDR:
+            mem_addr = get_dword(ram, incr_pc());
+            push(get_dword(ram, mem_addr));
+            break;
+        case MODE_DATA_32_ADDR_W:
+            mem_addr = get_dword(ram, incr_pc());
+            push(get_word(ram, mem_addr));
+            break;
+        case MODE_DATA_32_ADDR_B:
+            mem_addr = get_dword(ram, incr_pc());
+            push(get_byte(ram, mem_addr));
+            break;
+        case MODE_DATA_32_INDR:
+            mem_addr = get_dword(ram, incr_pc());
+            mem_addr = get_dword(ram, mem_addr);
+            push(get_dword(ram, mem_addr));
+            break;
+        case MODE_DATA_32_INDR_W:
+            mem_addr = get_dword(ram, incr_pc());
+            mem_addr = get_dword(ram, mem_addr);
+            push(get_word(ram, mem_addr));
+            break;
+        case MODE_DATA_32_INDR_B:
+            mem_addr = get_dword(ram, incr_pc());
+            mem_addr = get_dword(ram, mem_addr);
+            push(get_byte(ram, mem_addr));
+            break;
+        case MODE_REGISTER:
+            push(r[ic.d2]);
+            break;
+        case MODE_REGISTER_ADDR:
+            mem_addr = r[ic.d2];
+            push(get_dword(ram, mem_addr));
+            break;
+        case MODE_REGISTER_ADDR_W:
+            mem_addr = r[ic.d2];
+            push(get_word(ram, mem_addr));
+            break;
+        case MODE_REGISTER_ADDR_B:
+            mem_addr = r[ic.d2];
+            push(get_byte(ram, mem_addr));
+            break;
+        case MODE_REGISTER_INDR:
+            mem_addr = r[ic.d2];
+            mem_addr = get_dword(ram, mem_addr);
+            push(get_dword(ram, mem_addr));
+            break;
+        case MODE_REGISTER_INDR_W:
+            mem_addr = r[ic.d2];
+            mem_addr = get_dword(ram, mem_addr);
+            push(get_word(ram, mem_addr));
+            break;
+        case MODE_REGISTER_INDR_B:
+            mem_addr = r[ic.d2];
+            mem_addr = get_dword(ram, mem_addr);
+            push(get_byte(ram, mem_addr));
+            break;
+        default:
+            unsupported_mode(ic.mode);
     }
 }
 
@@ -451,65 +451,65 @@ void instr_pop(struct instruction ic)
 
     switch (ic.mode)
     {
-    case MODE_DATA_32_ADDR:
-        mem_addr = get_dword(ram, incr_pc());
-        store_dword(ram, mem_addr, pop());
-        break;
-    case MODE_DATA_32_ADDR_W:
-        mem_addr = get_dword(ram, incr_pc());
-        store_word(ram, mem_addr, pop());
-        break;
-    case MODE_DATA_32_ADDR_B:
-        mem_addr = get_dword(ram, incr_pc());
-        store_byte(ram, mem_addr, pop());
-        break;
-    case MODE_DATA_32_INDR:
-        mem_addr = get_dword(ram, incr_pc());
-        mem_addr = get_dword(ram, mem_addr);
-        store_dword(ram, mem_addr, pop());
-        break;
-    case MODE_DATA_32_INDR_W:
-        mem_addr = get_dword(ram, incr_pc());
-        mem_addr = get_dword(ram, mem_addr);
-        store_word(ram, mem_addr, pop());
-        break;
-    case MODE_DATA_32_INDR_B:
-        mem_addr = get_dword(ram, incr_pc());
-        mem_addr = get_dword(ram, mem_addr);
-        store_byte(ram, mem_addr, pop());
-        break;
-    case MODE_REGISTER:
-        r[ic.d2] = pop();
-        break;
-    case MODE_REGISTER_ADDR:
-        mem_addr = r[ic.d2];
-        store_dword(ram, mem_addr, pop());
-        break;
-    case MODE_REGISTER_ADDR_W:
-        mem_addr = r[ic.d2];
-        store_word(ram, mem_addr, pop());
-        break;
-    case MODE_REGISTER_ADDR_B:
-        mem_addr = r[ic.d2];
-        store_byte(ram, mem_addr, pop());
-        break;
-    case MODE_REGISTER_INDR:
-        mem_addr = r[ic.d2];
-        mem_addr = get_dword(ram, mem_addr);
-        store_dword(ram, mem_addr, pop());
-        break;
-    case MODE_REGISTER_INDR_W:
-        mem_addr = r[ic.d2];
-        mem_addr = get_dword(ram, mem_addr);
-        store_word(ram, mem_addr, pop());
-        break;
-    case MODE_REGISTER_INDR_B:
-        mem_addr = r[ic.d2];
-        mem_addr = get_dword(ram, mem_addr);
-        store_byte(ram, mem_addr, pop());
-        break;
-    default:
-        unsupported_mode(ic.mode);
+        case MODE_DATA_32_ADDR:
+            mem_addr = get_dword(ram, incr_pc());
+            store_dword(ram, mem_addr, pop());
+            break;
+        case MODE_DATA_32_ADDR_W:
+            mem_addr = get_dword(ram, incr_pc());
+            store_word(ram, mem_addr, pop());
+            break;
+        case MODE_DATA_32_ADDR_B:
+            mem_addr = get_dword(ram, incr_pc());
+            store_byte(ram, mem_addr, pop());
+            break;
+        case MODE_DATA_32_INDR:
+            mem_addr = get_dword(ram, incr_pc());
+            mem_addr = get_dword(ram, mem_addr);
+            store_dword(ram, mem_addr, pop());
+            break;
+        case MODE_DATA_32_INDR_W:
+            mem_addr = get_dword(ram, incr_pc());
+            mem_addr = get_dword(ram, mem_addr);
+            store_word(ram, mem_addr, pop());
+            break;
+        case MODE_DATA_32_INDR_B:
+            mem_addr = get_dword(ram, incr_pc());
+            mem_addr = get_dword(ram, mem_addr);
+            store_byte(ram, mem_addr, pop());
+            break;
+        case MODE_REGISTER:
+            r[ic.d2] = pop();
+            break;
+        case MODE_REGISTER_ADDR:
+            mem_addr = r[ic.d2];
+            store_dword(ram, mem_addr, pop());
+            break;
+        case MODE_REGISTER_ADDR_W:
+            mem_addr = r[ic.d2];
+            store_word(ram, mem_addr, pop());
+            break;
+        case MODE_REGISTER_ADDR_B:
+            mem_addr = r[ic.d2];
+            store_byte(ram, mem_addr, pop());
+            break;
+        case MODE_REGISTER_INDR:
+            mem_addr = r[ic.d2];
+            mem_addr = get_dword(ram, mem_addr);
+            store_dword(ram, mem_addr, pop());
+            break;
+        case MODE_REGISTER_INDR_W:
+            mem_addr = r[ic.d2];
+            mem_addr = get_dword(ram, mem_addr);
+            store_word(ram, mem_addr, pop());
+            break;
+        case MODE_REGISTER_INDR_B:
+            mem_addr = r[ic.d2];
+            mem_addr = get_dword(ram, mem_addr);
+            store_byte(ram, mem_addr, pop());
+            break;
+        default:
+            unsupported_mode(ic.mode);
     }
 }
 
@@ -525,65 +525,65 @@ void instr_peek(struct instruction ic)
 
     switch (ic.mode)
     {
-    case MODE_DATA_32_ADDR:
-        mem_addr = get_dword(ram, incr_pc());
-        store_dword(ram, mem_addr, peek(0));
-        break;
-    case MODE_DATA_32_ADDR_W:
-        mem_addr = get_dword(ram, incr_pc());
-        store_word(ram, mem_addr, peek(0));
-        break;
-    case MODE_DATA_32_ADDR_B:
-        mem_addr = get_dword(ram, incr_pc());
-        store_byte(ram, mem_addr, peek(0));
-        break;
-    case MODE_DATA_32_INDR:
-        mem_addr = get_dword(ram, incr_pc());
-        mem_addr = get_dword(ram, mem_addr);
-        store_dword(ram, mem_addr, peek(0));
-        break;
-    case MODE_DATA_32_INDR_W:
-        mem_addr = get_dword(ram, incr_pc());
-        mem_addr = get_dword(ram, mem_addr);
-        store_word(ram, mem_addr, peek(0));
-        break;
-    case MODE_DATA_32_INDR_B:
-        mem_addr = get_dword(ram, incr_pc());
-        mem_addr = get_dword(ram, mem_addr);
-        store_byte(ram, mem_addr, peek(0));
-        break;
-    case MODE_REGISTER:
-        r[ic.d2] = peek(0);
-        break;
-    case MODE_REGISTER_ADDR:
-        mem_addr = r[ic.d2];
-        store_dword(ram, mem_addr, peek(0));
-        break;
-    case MODE_REGISTER_ADDR_W:
-        mem_addr = r[ic.d2];
-        store_word(ram, mem_addr, peek(0));
-        break;
-    case MODE_REGISTER_ADDR_B:
-        mem_addr = r[ic.d2];
-        store_byte(ram, mem_addr, peek(0));
-        break;
-    case MODE_REGISTER_INDR:
-        mem_addr = r[ic.d2];
-        mem_addr = get_dword(ram, mem_addr);
-        store_dword(ram, mem_addr, peek(0));
-        break;
-    case MODE_REGISTER_INDR_W:
-        mem_addr = r[ic.d2];
-        mem_addr = get_dword(ram, mem_addr);
-        store_word(ram, mem_addr, peek(0));
-        break;
-    case MODE_REGISTER_INDR_B:
-        mem_addr = r[ic.d2];
-        mem_addr = get_dword(ram, mem_addr);
-        store_byte(ram, mem_addr, peek(0));
-        break;
-    default:
-        unsupported_mode(ic.mode);
+        case MODE_DATA_32_ADDR:
+            mem_addr = get_dword(ram, incr_pc());
+            store_dword(ram, mem_addr, peek(0));
+            break;
+        case MODE_DATA_32_ADDR_W:
+            mem_addr = get_dword(ram, incr_pc());
+            store_word(ram, mem_addr, peek(0));
+            break;
+        case MODE_DATA_32_ADDR_B:
+            mem_addr = get_dword(ram, incr_pc());
+            store_byte(ram, mem_addr, peek(0));
+            break;
+        case MODE_DATA_32_INDR:
+            mem_addr = get_dword(ram, incr_pc());
+            mem_addr = get_dword(ram, mem_addr);
+            store_dword(ram, mem_addr, peek(0));
+            break;
+        case MODE_DATA_32_INDR_W:
+            mem_addr = get_dword(ram, incr_pc());
+            mem_addr = get_dword(ram, mem_addr);
+            store_word(ram, mem_addr, peek(0));
+            break;
+        case MODE_DATA_32_INDR_B:
+            mem_addr = get_dword(ram, incr_pc());
+            mem_addr = get_dword(ram, mem_addr);
+            store_byte(ram, mem_addr, peek(0));
+            break;
+        case MODE_REGISTER:
+            r[ic.d2] = peek(0);
+            break;
+        case MODE_REGISTER_ADDR:
+            mem_addr = r[ic.d2];
+            store_dword(ram, mem_addr, peek(0));
+            break;
+        case MODE_REGISTER_ADDR_W:
+            mem_addr = r[ic.d2];
+            store_word(ram, mem_addr, peek(0));
+            break;
+        case MODE_REGISTER_ADDR_B:
+            mem_addr = r[ic.d2];
+            store_byte(ram, mem_addr, peek(0));
+            break;
+        case MODE_REGISTER_INDR:
+            mem_addr = r[ic.d2];
+            mem_addr = get_dword(ram, mem_addr);
+            store_dword(ram, mem_addr, peek(0));
+            break;
+        case MODE_REGISTER_INDR_W:
+            mem_addr = r[ic.d2];
+            mem_addr = get_dword(ram, mem_addr);
+            store_word(ram, mem_addr, peek(0));
+            break;
+        case MODE_REGISTER_INDR_B:
+            mem_addr = r[ic.d2];
+            mem_addr = get_dword(ram, mem_addr);
+            store_byte(ram, mem_addr, peek(0));
+            break;
+        default:
+            unsupported_mode(ic.mode);
     }
 }
 
@@ -605,22 +605,22 @@ void instr_jmp(struct instruction ic)
     {
         switch (ic.mode)
         {
-        case MODE_DEFAULT:
-            // Point the pc to the jmp location
-            pc = mem_addr - 4;
-            break;
-        case JUMP_MODE_JMPEQ:
-            if (zb_tst())
+            case MODE_DEFAULT:
                 // Point the pc to the jmp location
                 pc = mem_addr - 4;
-            break;
-        case JUMP_MODE_JMPNEQ:
-            if (!zb_tst())
-                // Point the pc to the jmp location
-                pc = mem_addr - 4;
-            break;
-        default:
-            unsupported_mode(ic.mode);
+                break;
+            case JUMP_MODE_JMPEQ:
+                if (zb_tst())
+                    // Point the pc to the jmp location
+                    pc = mem_addr - 4;
+                break;
+            case JUMP_MODE_JMPNEQ:
+                if (!zb_tst())
+                    // Point the pc to the jmp location
+                    pc = mem_addr - 4;
+                break;
+            default:
+                unsupported_mode(ic.mode);
         }
     }
 }
@@ -666,18 +666,18 @@ void instr_adv_print(struct instruction ic)
     // 2. print the 0 terminated string located in the memory pointed to by pr
     switch (ic.mode)
     {
-    case MODE_DEFAULT:
-        print((char)*pr);
-        break;
-    case MODE_EXTRA:
-        mem_addr = *pr;
-        char p_byte = '\00';
-        while ((p_byte = get_byte(ram, mem_addr++)))
-            print(p_byte);
-
-        break;
-    default:
-        unsupported_mode(ic.mode);
+        case MODE_DEFAULT:
+            print((char) *pr);
+            break;
+        case MODE_EXTRA:
+            mem_addr = *pr;
+            char p_byte = '\00';
+            while ((p_byte = get_byte(ram, mem_addr++)))
+                print(p_byte);
+
+            break;
+        default:
+            unsupported_mode(ic.mode);
     }
 }
 
@@ -693,15 +693,15 @@ void instr_adv_scan(struct instruction ic)
 
     switch (ic.mode)
     {
-    case MODE_DEFAULT:
-        // Scan the character literal into pr
-        scanf("%c", (char *)pr);
-        break;
-    case MODE_EXTRA:
-        mem_addr = *pr;
-        fgets((char *)(ram + mem_addr), *dr, stdin);
-        break;
-    default:
-        unsupported_mode(ic.mode);
+        case MODE_DEFAULT:
+            // Scan the character literal into pr
+            scanf("%c", (char *) pr);
+            break;
+        case MODE_EXTRA:
+            mem_addr = *pr;
+            fgets((char *) (ram + mem_addr), *dr, stdin);
+            break;
+        default:
+            unsupported_mode(ic.mode);
     }
 }
diff --git a/src/instructions/instructions.h b/src/instructions/instructions.h
index 13a6049..4728224 100644
--- a/src/instructions/instructions.h
+++ b/src/instructions/instructions.h
@@ -11,7 +11,7 @@
 #define INSTRUCTIONS_H
 // Basic instructions
 #define INSTR_EXIT 0x00
-#define INSTR_NOP 0xFF
+#define INSTR_NOOP 0xFF
 
 #define INSTR_PUSH 0xA0
 #define INSTR_POP 0xA1
diff --git a/blackbox_test.py b/test_programs.py
similarity index 99%
rename from blackbox_test.py
rename to test_programs.py
index dad9af8..181a042 100644
--- a/blackbox_test.py
+++ b/test_programs.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python
 """
-blackbox_test.py
+test_programs.py
 Matthew Brooks, 2018
 Tests mbvm using all of the programs in test_programs against their known
 output.
diff --git a/test_programs/test_programs.json b/test_programs/test_programs.json
index 70af86d..da7ddc2 100644
--- a/test_programs/test_programs.json
+++ b/test_programs/test_programs.json
@@ -14,8 +14,8 @@
     },
     {
       "name": "repeat_me",
-      "input" : "Everything's impossible until somebody does it",
+      "input": "Everything's impossible until somebody does it",
       "expected_output": "Everything's impossible until somebody does it"
     }
   ]
-}
\ No newline at end of file
+}
diff --git a/tests/instructions/test_instructions.c b/tests/instructions/test_instructions.c
index 6db158c..d820082 100644
--- a/tests/instructions/test_instructions.c
+++ b/tests/instructions/test_instructions.c
@@ -15,6 +15,15 @@
 #include "../../src/system/system.h"
 #include "../../src/vm/vm.h"
 
+// The instruction locations for the successive instructions after our push
+// to help with addressing and indirection
+static const uint32_t NEXT_INSTR = INSTRUCTION_SIZE;
+static const uint32_t NEXT2_INSTR = INSTRUCTION_SIZE * 2;
+static const uint32_t NEXT3_INSTR = INSTRUCTION_SIZE * 3;
+static const int SOURCE_IMMEDIATE = 1;
+static const int SOURCE_REGISTER = 2;
+static const uint32_t REGISTER_LOCATION = 0x0A000000;
+
 /**
  * The suite initialization function.
  * Returns zero on success, non-zero otherwise.
@@ -44,11 +53,26 @@ void test_instr_exit()
     deallocate();
 }
 
+/**
+ * Tests 'instr_noop'
+ */
+void test_instr_noop()
+{
+    allocate();
+    exec(create_instruction(INSTR_NOOP, EMPTY_BYTE, EMPTY_BYTE, EMPTY_BYTE));
+    // TODO: Not sure what to test here, just checking that the PC
+    // was incremented for now
+    CU_ASSERT(INSTRUCTION_SIZE == pc);
+    deallocate();
+}
+
 /**
  * Tests 'isntr_push()'.
  */
 void test_instr_push()
 {
+    // TODO: Create a util function similiar to pop_test_util()
+
     // MODE_IMMEDIATE_B
     allocate();
     exec(create_instruction(INSTR_PUSH, MODE_IMMEDIATE_B, EMPTY_BYTE,
@@ -71,12 +95,6 @@ void test_instr_push()
     CU_ASSERT(DUMMY_VALUE_32 == pop());
     deallocate();
 
-    // The instruction locations for the successive instructions after our push
-    // to help with addressing and indirection
-    const int NEXT_INSTR = INSTRUCTION_SIZE;
-    const int NEXT2_INSTR = INSTRUCTION_SIZE * 2;
-    const int NEXT3_INSTR = INSTRUCTION_SIZE * 3;
-
     // MODE_DATA_32_ADDR
     allocate();
     // Store address 2*instr in the next instruction (ram[instr])
@@ -224,4 +242,93 @@ void test_instr_push()
     deallocate();
 }
 
+/**
+ * A utility function to avoid duplication when testing pop() implementations.
+ */
+void pop_test_util(uint32_t push_value, uint8_t pop_mode, uint32_t get_location,
+                   int source)
+{
+    allocate();
+    push(push_value);
+
+    if (source == SOURCE_IMMEDIATE)
+    {
+        store_dword(ram, NEXT_INSTR, NEXT2_INSTR);
+
+        if (get_location == NEXT3_INSTR)
+            store_dword(ram, NEXT2_INSTR, NEXT3_INSTR);
+
+        exec(create_instruction(INSTR_POP, pop_mode, EMPTY_BYTE,
+                                EMPTY_BYTE));
+    }
+    else
+    {
+        //  We can point the register to next instruction by default
+        r[TEST_REGISTER] = NEXT_INSTR;
+
+        if (get_location == NEXT2_INSTR)
+            store_dword(ram, NEXT_INSTR, NEXT2_INSTR);
+
+        exec(create_instruction(INSTR_POP, pop_mode, EMPTY_BYTE,
+                                TEST_REGISTER));
+    }
+
+    if (get_location == REGISTER_LOCATION)
+    {
+        CU_ASSERT(push_value == r[TEST_REGISTER]);
+    }
+    else
+    {
+        switch (push_value)
+        {
+            case DUMMY_VALUE_32:
+            CU_ASSERT(push_value == get_dword(ram, get_location));
+                break;
+            case DUMMY_VALUE_16:
+            CU_ASSERT(push_value == get_word(ram, get_location));
+                break;
+            case DUMMY_VALUE_8:
+            CU_ASSERT(push_value == get_byte(ram, get_location));
+                break;
+            default:
+            CU_FAIL("Invalid push_value");
+        }
+    }
+
+    deallocate();
+}
+
+/**
+ * Tests 'isntr_pop()'.
+ */
+void test_instr_pop()
+{
+    pop_test_util(DUMMY_VALUE_32, MODE_DATA_32_ADDR, NEXT2_INSTR,
+                  SOURCE_IMMEDIATE);
+    pop_test_util(DUMMY_VALUE_16, MODE_DATA_32_ADDR_W, NEXT2_INSTR,
+                  SOURCE_IMMEDIATE);
+    pop_test_util(DUMMY_VALUE_8, MODE_DATA_32_ADDR_B, NEXT2_INSTR,
+                  SOURCE_IMMEDIATE);
+    pop_test_util(DUMMY_VALUE_32, MODE_DATA_32_INDR, NEXT3_INSTR,
+                  SOURCE_IMMEDIATE);
+    pop_test_util(DUMMY_VALUE_16, MODE_DATA_32_INDR_W, NEXT3_INSTR,
+                  SOURCE_IMMEDIATE);
+    pop_test_util(DUMMY_VALUE_8, MODE_DATA_32_INDR_B, NEXT3_INSTR,
+                  SOURCE_IMMEDIATE);
+    pop_test_util(DUMMY_VALUE_32, MODE_REGISTER, REGISTER_LOCATION,
+                  SOURCE_REGISTER);
+    pop_test_util(DUMMY_VALUE_32, MODE_REGISTER_ADDR, NEXT_INSTR,
+                  SOURCE_REGISTER);
+    pop_test_util(DUMMY_VALUE_16, MODE_REGISTER_ADDR_W, NEXT_INSTR,
+                  SOURCE_REGISTER);
+    pop_test_util(DUMMY_VALUE_8, MODE_REGISTER_ADDR_B, NEXT_INSTR,
+                  SOURCE_REGISTER);
+    pop_test_util(DUMMY_VALUE_32, MODE_REGISTER_INDR, NEXT2_INSTR,
+                  SOURCE_REGISTER);
+    pop_test_util(DUMMY_VALUE_16, MODE_REGISTER_INDR_W, NEXT2_INSTR,
+                  SOURCE_REGISTER);
+    pop_test_util(DUMMY_VALUE_8, MODE_REGISTER_INDR_B, NEXT2_INSTR,
+                  SOURCE_REGISTER);
+}
+
 // TODO: Add the rest
diff --git a/tests/instructions/test_instructions.h b/tests/instructions/test_instructions.h
index bcffb96..c653bcd 100644
--- a/tests/instructions/test_instructions.h
+++ b/tests/instructions/test_instructions.h
@@ -14,5 +14,7 @@
 int init_instructions_test_suite();
 int clean_instructions_test_suite();
 void test_instr_exit();
+void test_instr_noop();
 void test_instr_push();
+void test_instr_pop();
 #endif
\ No newline at end of file
diff --git a/tests/test_registry.c b/tests/test_registry.c
index 03c61de..68d0f99 100644
--- a/tests/test_registry.c
+++ b/tests/test_registry.c
@@ -24,7 +24,9 @@ void add_instructions_tests(CU_pSuite p_suite)
                            clean_instructions_test_suite);
     // Add the tests
     CU_add_test(p_suite, "test of instr_exit()", test_instr_exit);
+    CU_add_test(p_suite, "test of instr_noop()", test_instr_noop);
     CU_add_test(p_suite, "test of instr_push()", test_instr_push);
+    CU_add_test(p_suite, "test of instr_pop()", test_instr_pop);
     // TODO: Add the rest
 }
 
diff --git a/tests/vm/test_vm.c b/tests/vm/test_vm.c
index c1d1871..988e925 100644
--- a/tests/vm/test_vm.c
+++ b/tests/vm/test_vm.c
@@ -117,7 +117,7 @@ void test_exec_program()
 {
     allocate();
     uint32_t test_instructions[2] = {
-            create_instruction(INSTR_NOP, EMPTY_BYTE, EMPTY_BYTE, EMPTY_BYTE),
+            create_instruction(INSTR_NOOP, EMPTY_BYTE, EMPTY_BYTE, EMPTY_BYTE),
             create_instruction(INSTR_EXIT, EMPTY_BYTE, EMPTY_BYTE, EMPTY_BYTE)};
     load_program(test_instructions,
                  sizeof(test_instructions) / sizeof(test_instructions[0]),