All unit tests

.vscode/settings.json

@@ -2,5 +2,48 @@
     "files.exclude": {
         "**/zig-cache/**": true,
         "**/zig-out/**": true
+    },
+    "cmake.sourceDirectory": "${workspaceFolder}/cplusplus",
+    "files.associations": {
+        "__bit_reference": "cpp",
+        "__bits": "cpp",
+        "__config": "cpp",
+        "__debug": "cpp",
+        "__nullptr": "cpp",
+        "__split_buffer": "cpp",
+        "__string": "cpp",
+        "__threading_support": "cpp",
+        "__tuple": "cpp",
+        "atomic": "cpp",
+        "cctype": "cpp",
+        "chrono": "cpp",
+        "cmath": "cpp",
+        "compare": "cpp",
+        "concepts": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "exception": "cpp",
+        "initializer_list": "cpp",
+        "iosfwd": "cpp",
+        "limits": "cpp",
+        "memory": "cpp",
+        "new": "cpp",
+        "numeric": "cpp",
+        "random": "cpp",
+        "ratio": "cpp",
+        "stdexcept": "cpp",
+        "string": "cpp",
+        "string_view": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "typeinfo": "cpp",
+        "variant": "cpp",
+        "vector": "cpp"
     }
 }

cplusplus/include/chip8/cpu.h

@@ -40,7 +40,11 @@ namespace Chip8 {
                 std::shared_ptr<Display> display,
                 std::shared_ptr<Keyboard> keyboard);
 
-            int getPc() { return _pc; }
+            uint16_t getPc() { return _pc; }
+            uint16_t getIndex() { return _index; }
+            void setDelayTimer(uint8_t value) { _delayTimer = value; }
+            uint8_t getDelayTimer() { return _delayTimer; }
+            uint8_t getSoundTimer() { return _soundTimer; }
 
         private:
             uint16_t getOpcode();

cplusplus/tests/source/should_add_value_to_value_in_registry.cpp

@@ -0,0 +1,16 @@
+#include "tests_common.h"
+
+int main() {
+    // arrange
+    auto memory = std::make_shared<Chip8::Memory>();
+    auto registers = std::make_shared<Chip8::Registers>();
+    auto cpu = std::make_shared<Chip8::CPU>(memory, registers);
+    uint8_t data[] = { 0x60, 0x01, 0x70, 0x01 };
+    memory->load(512, data, sizeof(data));
+
+    // act
+    emulate(cpu, sizeof(data));
+
+    // assert
+    assert(0x2 == registers->get(0));
+}

cplusplus/tests/source/should_add_value_to_value_in_registry_and_resolve_overflow.cpp

@@ -0,0 +1,16 @@
+#include "tests_common.h"
+
+int main() {
+    // arrange
+    auto memory = std::make_shared<Chip8::Memory>();
+    auto registers = std::make_shared<Chip8::Registers>();
+    auto cpu = std::make_shared<Chip8::CPU>(memory, registers);
+    uint8_t data[] = { 0x60, 0xFF, 0x70, 0xFF };
+    memory->load(512, data, sizeof(data));
+
+    // act
+    emulate(cpu, sizeof(data));
+
+    // assert
+    assert(254 == registers->get(0));
+}

cplusplus/tests/source/should_not_skip_next_instruction_if_equals.cpp

@@ -0,0 +1,16 @@
+#include "tests_common.h"
+
+int main() {
+    // arrange
+    auto memory = std::make_shared<Chip8::Memory>();
+    auto registers = std::make_shared<Chip8::Registers>();
+    auto cpu = std::make_shared<Chip8::CPU>(memory, registers);
+    uint8_t data[] = { 0x60, 0x01, 0x40, 0x01 };
+    memory->load(512, data, sizeof(data));
+
+    // act
+    emulate(cpu, sizeof(data));
+
+    // assert
+    assert(516 == cpu->getPc());
+}

cplusplus/tests/source/should_not_skip_next_instruction_if_vx_not_equals_vy.cpp

@@ -0,0 +1,16 @@
+#include "tests_common.h"
+
+int main() {
+    // arrange
+    auto memory = std::make_shared<Chip8::Memory>();
+    auto registers = std::make_shared<Chip8::Registers>();
+    auto cpu = std::make_shared<Chip8::CPU>(memory, registers);
+    uint8_t data[] = { 0x60, 0x01, 0x61, 0x02, 0x50, 0x10 };
+    memory->load(512, data, sizeof(data));
+
+    // act
+    emulate(cpu, sizeof(data));
+
+    // assert
+    assert(518 == cpu->getPc());
+}

cplusplus/tests/source/should_skip_next_instruction_if_vx_equals_vy.cpp

@@ -0,0 +1,16 @@
+#include "tests_common.h"
+
+int main() {
+    // arrange
+    auto memory = std::make_shared<Chip8::Memory>();
+    auto registers = std::make_shared<Chip8::Registers>();
+    auto cpu = std::make_shared<Chip8::CPU>(memory, registers);
+    uint8_t data[] = { 0x60, 0x01, 0x61, 0x01, 0x50, 0x10 };
+    memory->load(512, data, sizeof(data));
+
+    // act
+    emulate(cpu, sizeof(data));
+
+    // assert
+    assert(520 == cpu->getPc());
+}

cplusplus/tests/source/should_test_opcode_0x6000.cpp

@@ -0,0 +1,16 @@
+#include "tests_common.h"
+
+int main() {
+    // arrange
+    auto memory = std::make_shared<Chip8::Memory>();
+    auto registers = std::make_shared<Chip8::Registers>();
+    auto cpu = std::make_shared<Chip8::CPU>(memory, registers);
+    uint8_t data[] = { 0x60, 0x01 };
+    memory->load(512, data, sizeof(data));
+
+    // act
+    emulate(cpu, sizeof(data));
+
+    // assert
+    assert(0x1 == registers->get(0));
+}

cplusplus/tests/source/should_test_opcode_0x8xy0.cpp

@@ -0,0 +1,18 @@
+#include "tests_common.h"
+
+int main() {
+    // arrange
+    auto memory = std::make_shared<Chip8::Memory>();
+    auto registers = std::make_shared<Chip8::Registers>();
+    auto cpu = std::make_shared<Chip8::CPU>(memory, registers);
+    uint8_t data[] = { 0x60, 0x01, 0x62, 0x02, 0x80, 0x20 };
+    memory->load(512, data, sizeof(data));
+
+    // act
+    emulate(cpu, 4);
+
+    // assert
+    assert(0x1 == registers->get(0));
+    emulate(cpu, 2);
+    assert(0x2 == registers->get(0));
+}

cplusplus/tests/source/should_test_opcode_0x8xy1.cpp

@@ -0,0 +1,16 @@
+#include "tests_common.h"
+
+int main() {
+    // arrange
+    auto memory = std::make_shared<Chip8::Memory>();
+    auto registers = std::make_shared<Chip8::Registers>();
+    auto cpu = std::make_shared<Chip8::CPU>(memory, registers);
+    uint8_t data[] = { 0x60, 0x01, 0x61, 0x06, 0x80, 0x11 };
+    memory->load(512, data, sizeof(data));
+
+    // act
+    emulate(cpu, sizeof(data));
+
+    // assert
+    assert(0x7 == registers->get(0));
+}

cplusplus/tests/source/should_test_opcode_0x8xy2.cpp

@@ -0,0 +1,16 @@
+#include "tests_common.h"
+
+int main() {
+    // arrange
+    auto memory = std::make_shared<Chip8::Memory>();
+    auto registers = std::make_shared<Chip8::Registers>();
+    auto cpu = std::make_shared<Chip8::CPU>(memory, registers);
+    uint8_t data[] = { 0x60, 0x0C, 0x61, 0x06, 0x80, 0x12 };
+    memory->load(512, data, sizeof(data));
+
+    // act
+    emulate(cpu, sizeof(data));
+
+    // assert
+    assert(0x4 == registers->get(0));
+}

cplusplus/tests/source/should_test_opcode_0x8xy3.cpp

@@ -0,0 +1,16 @@
+#include "tests_common.h"
+
+int main() {
+    // arrange
+    auto memory = std::make_shared<Chip8::Memory>();
+    auto registers = std::make_shared<Chip8::Registers>();
+    auto cpu = std::make_shared<Chip8::CPU>(memory, registers);
+    uint8_t data[] = { 0x60, 0x09, 0x61, 0x05, 0x80, 0x13 };
+    memory->load(512, data, sizeof(data));
+
+    // act
+    emulate(cpu, sizeof(data));
+
+    // assert
+    assert(12 == registers->get(0));
+}

cplusplus/tests/source/should_test_opcode_0x8xy4_no_carry_set_register_f_to_zero.cpp

@@ -0,0 +1,17 @@
+#include "tests_common.h"
+
+int main() {
+    // arrange
+    auto memory = std::make_shared<Chip8::Memory>();
+    auto registers = std::make_shared<Chip8::Registers>();
+    auto cpu = std::make_shared<Chip8::CPU>(memory, registers);
+    uint8_t data[] = { 0x60, 0x01, 0x61, 0x01, 0x80, 0x14 };
+    memory->load(512, data, sizeof(data));
+
+    // act
+    emulate(cpu, sizeof(data));
+
+    // assert
+    assert(0x2 == registers->get(0));
+    assert(0 == registers->get(0xF));
+}

cplusplus/tests/source/should_test_opcode_0x8xy4_with_carry_set_register_f_to_one.cpp

@@ -0,0 +1,17 @@
+#include "tests_common.h"
+
+int main() {
+    // arrange
+    auto memory = std::make_shared<Chip8::Memory>();
+    auto registers = std::make_shared<Chip8::Registers>();
+    auto cpu = std::make_shared<Chip8::CPU>(memory, registers);
+    uint8_t data[] = { 0x60, 0xF1, 0x61, 0xF1, 0x80, 0x14};
+    memory->load(512, data, sizeof(data));
+
+    // act
+    emulate(cpu, sizeof(data));
+
+    // assert
+    assert(226 == registers->get(0));
+    assert(1 == registers->get(0xF));
+}

cplusplus/tests/source/should_test_opcode_0x8xy5_if_sum_is_negative_value.cpp

@@ -0,0 +1,17 @@
+#include "tests_common.h"
+
+int main() {
+    // arrange
+    auto memory = std::make_shared<Chip8::Memory>();
+    auto registers = std::make_shared<Chip8::Registers>();
+    auto cpu = std::make_shared<Chip8::CPU>(memory, registers);
+    uint8_t data[] = { 0x60, 0x02, 0x61, 0x03, 0x80, 0x15 };
+    memory->load(512, data, sizeof(data));
+
+    // act
+    emulate(cpu, sizeof(data));
+
+    // assert
+    assert(0xFF == registers->get(0));
+    assert(0 == registers->get(0xF));
+}

cplusplus/tests/source/should_test_opcode_0x8xy5_if_sum_is_non_negative_value.cpp

@@ -0,0 +1,17 @@
+#include "tests_common.h"
+
+int main() {
+    // arrange
+    auto memory = std::make_shared<Chip8::Memory>();
+    auto registers = std::make_shared<Chip8::Registers>();
+    auto cpu = std::make_shared<Chip8::CPU>(memory, registers);
+    uint8_t data[] = { 0x60, 0x03, 0x61, 0x02, 0x80, 0x15 };
+    memory->load(512, data, sizeof(data));
+
+    // act
+    emulate(cpu, sizeof(data));
+
+    // assert
+    assert(1 == registers->get(0));
+    assert(1 == registers->get(0xF));
+}

cplusplus/tests/source/should_test_opcode_0x8xy6_if_sum_has_least_significant_bit_of_one.cpp

@@ -0,0 +1,17 @@
+#include "tests_common.h"
+
+int main() {
+    // arrange
+    auto memory = std::make_shared<Chip8::Memory>();
+    auto registers = std::make_shared<Chip8::Registers>();
+    auto cpu = std::make_shared<Chip8::CPU>(memory, registers);
+    uint8_t data[] = { 0x60, 0x03, 0x80, 0x16 };
+    memory->load(512, data, sizeof(data));
+
+    // act
+    emulate(cpu, sizeof(data));
+
+    // assert
+    assert(0x1 == registers->get(0));
+    assert(0x1 == registers->get(0xF));
+}

cplusplus/tests/source/should_test_opcode_0x8xy6_if_sum_has_least_significant_bit_of_zero.cpp

@@ -0,0 +1,17 @@
+#include "tests_common.h"
+
+int main() {
+    // arrange
+    auto memory = std::make_shared<Chip8::Memory>();
+    auto registers = std::make_shared<Chip8::Registers>();
+    auto cpu = std::make_shared<Chip8::CPU>(memory, registers);
+    uint8_t data[] = { 0x60, 0x02, 0x80, 0x16 };
+    memory->load(512, data, sizeof(data));
+
+    // act
+    emulate(cpu, sizeof(data));
+
+    // assert
+    assert(0x1 == registers->get(0));
+    assert(0x0 == registers->get(0xF));
+}

cplusplus/tests/source/should_test_opcode_0x8xy7_if_there_is_borrow_set_vf_to_zero.cpp

@@ -0,0 +1,17 @@
+#include "tests_common.h"
+
+int main() {
+    // arrange
+    auto memory = std::make_shared<Chip8::Memory>();
+    auto registers = std::make_shared<Chip8::Registers>();
+    auto cpu = std::make_shared<Chip8::CPU>(memory, registers);
+    uint8_t data[] = { 0x60, 0x02, 0x61, 0x03, 0x80, 0x17 };
+    memory->load(512, data, sizeof(data));
+
+    // act
+    emulate(cpu, sizeof(data));
+
+    // assert
+    assert(0x1 == registers->get(0));
+    assert(0x1 == registers->get(0xF));
+}

cplusplus/tests/source/should_test_opcode_0x8xy7_if_there_is_no_borrow_set_vf_to_one.cpp

@@ -0,0 +1,17 @@
+#include "tests_common.h"
+
+int main() {
+    // arrange
+    auto memory = std::make_shared<Chip8::Memory>();
+    auto registers = std::make_shared<Chip8::Registers>();
+    auto cpu = std::make_shared<Chip8::CPU>(memory, registers);
+    uint8_t data[] = { 0x60, 0x02, 0x61, 0x03, 0x80, 0x17 };
+    memory->load(512, data, sizeof(data));
+
+    // act
+    emulate(cpu, sizeof(data));
+
+    // assert
+    assert(0x1 == registers->get(0));
+    assert(0x1 == registers->get(0xF));
+}

cplusplus/tests/source/should_test_opcode_0x8xye_mbs_should_be_zero.cpp

@@ -0,0 +1,17 @@
+#include "tests_common.h"
+
+int main() {
+    // arrange
+    auto memory = std::make_shared<Chip8::Memory>();
+    auto registers = std::make_shared<Chip8::Registers>();
+    auto cpu = std::make_shared<Chip8::CPU>(memory, registers);
+    uint8_t data[] = { 0x60, 0xFF, 0x80, 0x0E };
+    memory->load(512, data, sizeof(data));
+
+    // act
+    emulate(cpu, sizeof(data));
+
+    // assert
+    assert(0xFE == registers->get(0));
+    assert(0x1 == registers->get(0xF));
+}