diff --git a/CMakeLists.txt b/CMakeLists.txt index ae93850..cba781e 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -38,6 +38,8 @@ set(SOURCES sources/APU/DSP/DSP.cpp sources/APU/DSP/DSP.hpp sources/Renderer/IRenderer.hpp + sources/Renderer/NoRenderer.cpp + sources/Renderer/NoRenderer.hpp sources/Exceptions/InvalidAction.hpp sources/Cartridge/InterruptVectors.hpp sources/Memory/RectangleShadow.cpp @@ -159,68 +161,36 @@ target_link_libraries(ComSquare add_executable(unit_tests EXCLUDE_FROM_ALL ${SOURCES} - tests/CPU/testAddressingMode.cpp - tests/CPU/testInterupts.cpp - tests/testMemoryBus.cpp + tests/MainTest.cpp tests/tests.hpp - tests/APU/testAPUInstructions.cpp - tests/APU/testAPU.cpp - tests/CPU/testAddressingMode.cpp - tests/PPU/testPpuWrite.cpp - tests/PPU/testPpuWriteFromVmain.cpp - tests/CPU/Math/testADC.cpp - tests/CPU/testStore.cpp - tests/CPU/testInternal.cpp - tests/CPU/testBits.cpp - tests/APU/testOperand.cpp - tests/CPU/Math/testSBC.cpp - tests/CPU/testTransfers.cpp - tests/CPU/Math/testOthersMath.cpp - tests/testRectangleMemory.cpp - tests/CPU/Math/testCMP.cpp - tests/CPU/testDMA.cpp - tests/CPU/testAddressingMode.cpp tests/CPU/testInterupts.cpp - tests/testMemoryBus.cpp - tests/tests.hpp - tests/APU/testAPUInstructions.cpp - tests/APU/testAPU.cpp - tests/CPU/testAddressingMode.cpp - tests/PPU/testPpuWrite.cpp - tests/PPU/testPpuWriteFromVmain.cpp - tests/CPU/Math/testADC.cpp - tests/CPU/testStore.cpp - tests/CPU/testInternal.cpp - tests/CPU/testBits.cpp - tests/APU/testOperand.cpp - tests/CPU/Math/testSBC.cpp - tests/CPU/testTransfers.cpp - tests/CPU/Math/testOthersMath.cpp - tests/testRectangleMemory.cpp - tests/CPU/Math/testCMP.cpp - tests/PPU/testBackground.cpp - tests/PPU/testPpuRead.cpp - tests/CPU/testDMA.cpp - tests/CPU/testAddressingMode.cpp - tests/CPU/testInterupts.cpp - tests/testMemoryBus.cpp - tests/tests.hpp - tests/APU/testAPUInstructions.cpp - tests/APU/testAPU.cpp - tests/CPU/testAddressingMode.cpp - tests/PPU/testPpuWrite.cpp - tests/PPU/testPpuWriteFromVmain.cpp - tests/CPU/Math/testADC.cpp - tests/CPU/testStore.cpp - tests/CPU/testInternal.cpp - tests/CPU/testBits.cpp - tests/APU/testOperand.cpp - tests/CPU/Math/testSBC.cpp - tests/CPU/testTransfers.cpp - tests/CPU/Math/testOthersMath.cpp - tests/testRectangleMemory.cpp - tests/CPU/Math/testCMP.cpp - tests/CPU/testDMA.cpp +# tests/APU/testAPUInstructions.cpp +# tests/APU/testAPU.cpp +# tests/PPU/testPpuWrite.cpp +# tests/PPU/testPpuWriteFromVmain.cpp +# tests/CPU/Math/testADC.cpp +# tests/CPU/testStore.cpp +# tests/CPU/testInternal.cpp +# tests/CPU/testBits.cpp +# tests/APU/testOperand.cpp +# tests/CPU/Math/testSBC.cpp +# tests/CPU/testTransfers.cpp +# tests/CPU/Math/testOthersMath.cpp +# tests/testRectangleMemory.cpp +# tests/CPU/Math/testCMP.cpp +# tests/CPU/testDMA.cpp +# tests/CPU/testAddressingMode.cpp +# tests/testMemoryBus.cpp ) -target_link_libraries(unit_tests criterion -lgcov) -target_compile_options(unit_tests PUBLIC -fprofile-arcs -ftest-coverage) \ No newline at end of file + +if (CMAKE_COMPILER_IS_GNUCXX) +# target_link_libraries(unit_tests PRIVATE -lgcov) +# target_compile_options(unit_tests PUBLIC -fprofile-arcs -ftest-coverage) +endif() + +find_package(Catch2 QUIET) +if (NOT Catch2_FOUND) + set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake-dependencies) + find_package(Catch2 REQUIRED) +endif () +target_link_libraries(unit_tests PRIVATE Catch2::Catch2) diff --git a/cmake-dependencies/FindCatch2.cmake b/cmake-dependencies/FindCatch2.cmake new file mode 100644 index 0000000..155962e --- /dev/null +++ b/cmake-dependencies/FindCatch2.cmake @@ -0,0 +1,13 @@ +CMAKE_MINIMUM_REQUIRED(VERSION 3.11) + + +if (NOT Catch2_FOUND) + Include(FetchContent) + + FetchContent_Declare( + Catch2 + GIT_REPOSITORY https://github.com/catchorg/Catch2.git + GIT_TAG v2.13.6) + + FetchContent_MakeAvailable(Catch2) +endif() diff --git a/sources/CPU/CPU.hpp b/sources/CPU/CPU.hpp index 8099e7f..023f407 100644 --- a/sources/CPU/CPU.hpp +++ b/sources/CPU/CPU.hpp @@ -5,11 +5,11 @@ #ifndef COMSQUARE_CPU_HPP #define COMSQUARE_CPU_HPP -#include "../Memory/AMemory.hpp" -#include "../Memory/MemoryBus.hpp" -#include "../Models/Int24.hpp" -#include "../Cartridge/Cartridge.hpp" -#include "../Memory/AMemory.hpp" +#include "Memory/AMemory.hpp" +#include "Memory/MemoryBus.hpp" +#include "Models/Int24.hpp" +#include "Cartridge/Cartridge.hpp" +#include "Memory/AMemory.hpp" #include "Instruction.hpp" #include "DMA/DMA.hpp" diff --git a/sources/Cartridge/Cartridge.cpp b/sources/Cartridge/Cartridge.cpp index 3a19e61..6f50e11 100644 --- a/sources/Cartridge/Cartridge.cpp +++ b/sources/Cartridge/Cartridge.cpp @@ -11,6 +11,8 @@ namespace ComSquare::Cartridge { + constexpr unsigned HeaderSize = 0x40u; + Cartridge::Cartridge(const std::string &romPath) : Ram::Ram(0, Rom, "Cartridge"), _romPath(romPath) @@ -187,9 +189,12 @@ namespace ComSquare::Cartridge this->_type = Audio; return false; } - uint32_t headerAddress = this->_getHeaderAddress(); - this->_type = Game; + + uint32_t headerAddress = this->_getHeaderAddress(); + if (headerAddress + HeaderSize > this->_size) + return false; + this->header = this->_mapHeader(headerAddress); this->header.gameName = std::string(reinterpret_cast(&this->_data[headerAddress]), 21); if ((headerAddress + 0x40u) & 0x200u) { diff --git a/sources/Cartridge/Cartridge.hpp b/sources/Cartridge/Cartridge.hpp index d194715..d869c24 100644 --- a/sources/Cartridge/Cartridge.hpp +++ b/sources/Cartridge/Cartridge.hpp @@ -6,11 +6,11 @@ #include #include -#include "../Memory/AMemory.hpp" -#include "../Models/Int24.hpp" -#include "../Memory/ARectangleMemory.hpp" +#include "Memory/AMemory.hpp" +#include "Models/Int24.hpp" +#include "Memory/ARectangleMemory.hpp" #include "InterruptVectors.hpp" -#include "../Ram/Ram.hpp" +#include "Ram/Ram.hpp" namespace ComSquare::Cartridge { diff --git a/sources/Debugger/CPU/SymbolLoaders/WlaDx.cpp b/sources/Debugger/CPU/SymbolLoaders/WlaDx.cpp index ab439c0..f275da6 100644 --- a/sources/Debugger/CPU/SymbolLoaders/WlaDx.cpp +++ b/sources/Debugger/CPU/SymbolLoaders/WlaDx.cpp @@ -16,6 +16,7 @@ namespace ComSquare::Debugger std::smatch match; std::regex re(R"(\[(\S+)\])"); + return ret; while (symbolFile) { if (line.empty()) { std::getline(symbolFile, line); diff --git a/sources/PPU/Background.cpp b/sources/PPU/Background.cpp index dc90389..af2279e 100644 --- a/sources/PPU/Background.cpp +++ b/sources/PPU/Background.cpp @@ -6,6 +6,7 @@ #include "PPU.hpp" #include "Background.hpp" #include +#include #include "Tile.hpp" #include "PPUUtils.hpp" #include "Models/Vector2.hpp" @@ -25,9 +26,9 @@ namespace ComSquare::PPU _bgNumber(backGroundNumber), _tileBuffer({{{0}}}), _vram(ppu.vram), - _cgram(ppu.cgram), - buffer({{{0}}}) + _cgram(ppu.cgram) { + memset(this->buffer, 0, sizeof(this->buffer)); this->_tileRenderer.setRam(this->_vram); this->_tileRenderer.setCgram(this->_cgram); } diff --git a/sources/PPU/Background.hpp b/sources/PPU/Background.hpp index abbc00e..d3563ac 100644 --- a/sources/PPU/Background.hpp +++ b/sources/PPU/Background.hpp @@ -67,7 +67,7 @@ namespace ComSquare::PPU //! @brief The size of the background (x, y) Vector2 backgroundSize; //! @brief The output buffer (pixels are written on it) - std::array, 1024> buffer; + uint32_t buffer[1024][1024]; //! @brief Render a background on his internal buffer void renderBackground(); diff --git a/sources/PPU/PPU.cpp b/sources/PPU/PPU.cpp index 27dc900..75bf3b1 100644 --- a/sources/PPU/PPU.cpp +++ b/sources/PPU/PPU.cpp @@ -4,6 +4,7 @@ #include #include +#include #include "PPU.hpp" #include "Exceptions/NotImplementedException.hpp" #include "Exceptions/InvalidAddress.hpp" @@ -13,9 +14,9 @@ namespace ComSquare::PPU { PPU::PPU(Renderer::IRenderer &renderer): - vram(new Ram::Ram(VramSize, ComSquare::VRam, "VRAM")), - oamram(new Ram::Ram(OAMRamSize, ComSquare::OAMRam, "OAMRAM")), - cgram(new Ram::Ram(CGRamSize, ComSquare::CGRam, "CGRAM")), + vram(std::make_shared(VramSize, ComSquare::VRam, "VRAM")), + oamram(std::make_shared(OAMRamSize, ComSquare::OAMRam, "OAMRAM")), + cgram(std::make_shared(CGRamSize, ComSquare::CGRam, "CGRAM")), _renderer(renderer), _backgrounds{ Background(*this, 1, false), @@ -26,179 +27,11 @@ namespace ComSquare::PPU Background(*this, 3, true), Background(*this, 4, false), Background(*this, 4, true) - }, - _mainScreen({{{0}}}), - _subScreen({{{0}}}) + } { + memset(this->_mainScreen, 0, sizeof(this->_mainScreen)); + memset(this->_subScreen, 0, sizeof(this->_subScreen)); this->_registers._isLowByte = true; - - //colors for the cgram - this->cgram->write(2, 0xE0); - this->cgram->write(3, 0x7F); - this->cgram->write(4, 0x1F); // 0x1F - this->cgram->write(6, 0xFF); - this->cgram->write(7, 0x03); - this->cgram->write(66, 0xE0); - this->cgram->write(67, 0x7F); - - //tiles - int vram_test[] = { - 00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, -00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, -03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03, -0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0, -00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff, -00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff, -03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0xff,0xff,0xff,0xff, -0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xff,0xff,0xff,0xff, -00,0xc0,0x00,0xe0,0x00,0x70,0x00,0x38,0x00,0x1c,0x00,0x0e,0x00,0x07,0x00,0x03, -00,0x03,0x00,0x07,0x00,0x0e,0x00,0x1c,0x00,0x38,0x00,0x70,0x00,0xe0,0x00,0xc0, -00,0x07,0x00,0x0f,0x00,0x18,0x00,0x30,0x00,0x60,0x00,0xc0,0x00,0xc0,0x00,0xc0, -00,0xe0,0x00,0xf0,0x00,0x18,0x00,0x0c,0x00,0x06,0x00,0x03,0x00,0x03,0x00,0x03, -0xfc,0x00,0xf8,0x00,0xf0,0x00,0xe0,0x00,0xc0,0x00,0x80,0x00,0x00,0x00,0x00,0x00, -0x3f,0x00,0x1f,0x00,0x0f,0x00,0x07,0x00,0x03,0x00,0x01,0x00,0x00,0x00,0x00,0x00, -00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, -00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, -00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, -00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, -03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03, -0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0, -0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, -0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, -0xff,0xff,0xff,0xff,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03,0x03, -0xff,0xff,0xff,0xff,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0, -00,0x03,0x00,0x07,0x00,0x0e,0x00,0x1c,0x00,0x38,0x00,0x70,0x00,0xe0,0x00,0xc0, -00,0xc0,0x00,0xe0,0x00,0x70,0x00,0x38,0x00,0x1c,0x00,0x0e,0x00,0x07,0x00,0x03, -00,0xc0,0x00,0xc0,0x00,0xc0,0x00,0x60,0x00,0x30,0x00,0x18,0x00,0x0f,0x00,0x07, -00,0x03,0x00,0x03,0x00,0x03,0x00,0x06,0x00,0x0c,0x00,0x18,0x00,0xf0,0x00,0xe0, -00,0x00,0x00,0x00,0x80,0x00,0xc0,0x00,0xe0,0x00,0xf0,0x00,0xf8,0x00,0xfc,0x00, -00,0x00,0x00,0x00,0x01,0x00,0x03,0x00,0x07,0x00,0x0f,00,0x1f,00,0x3f,00, -1 - }; - /* int *cgram_test = Utils::get_dump_cgram(); - for (int i = 0; cgram_test[i] != -1; i++) { - this->cgram->write(i, cgram_test[i]); - } */ - - //int *vram_test = Utils::get_dump_vram(); - for (int i = 0; vram_test[i] != -1; i++) { - this->vram->write(i, vram_test[i]); - } - int vram_test_2[] = {8, 00, 02, 00, 0x0A, 00, 02, 00, 0x0A, 00, 00, 00, 00, 00, 00, -1}; - for (int i = 0; vram_test_2[i] != -1; i++) { - this->vram->write(i + 0x8000, vram_test_2[i]); - } - int vram_test_3[] = {8, 00, 02, 00, 0x8, 00, 02, 00, 0x8, 00, 00, 00, 00, 00, 00, -1}; - for (int i = 0; vram_test_3[i] != -1; i++) { - this->vram->write(i + 0x8080, vram_test_3[i]); - } - int vram_test_4[] = {8, 00, 02, 00, 0x0A, 00, 02, 00, 0x0A, 00, 00, 00, 00, 00, 00, -1}; - for (int i = 0; vram_test_4[i] != -1; i++) { - this->vram->write(i + 0x8100, vram_test_4[i]); - } - this->vram->write(0x8040, 04); - this->vram->write(0x8042, 06); - this->vram->write(0x8044, 04); - this->vram->write(0x8046, 06); - this->vram->write(0x8048, 04); - - this->vram->write(0x80C0, 04); - this->vram->write(0x80C2, 06); - this->vram->write(0x80C4, 04); - this->vram->write(0x80C6, 06); - this->vram->write(0x80C8, 04); - - this->vram->write(0xC000, 0x0C); - - //registers tic tac toe - this->_registers._bgmode.bgMode = 0; - this->_backgrounds[0].setBpp(this->getBPP(1)); - this->_backgrounds[1].setBpp(this->getBPP(1)); - this->_backgrounds[2].setBpp(this->getBPP(2)); - this->_backgrounds[3].setBpp(this->getBPP(2)); - this->_backgrounds[4].setBpp(this->getBPP(3)); - this->_backgrounds[5].setBpp(this->getBPP(3)); - this->_backgrounds[6].setBpp(this->getBPP(4)); - this->_backgrounds[7].setBpp(this->getBPP(4)); - - this->_registers._bgmode.characterSizeBg1 = true; - this->_registers._bgmode.characterSizeBg2 = true; - this->_backgrounds[0].setCharacterSize(this->getCharacterSize(1)); - this->_backgrounds[1].setCharacterSize(this->getCharacterSize(1)); - this->_backgrounds[2].setCharacterSize(this->getCharacterSize(2)); - this->_backgrounds[3].setCharacterSize(this->getCharacterSize(2)); - this->_backgrounds[4].setCharacterSize(this->getCharacterSize(3)); - this->_backgrounds[5].setCharacterSize(this->getCharacterSize(3)); - this->_backgrounds[6].setCharacterSize(this->getCharacterSize(4)); - this->_backgrounds[7].setCharacterSize(this->getCharacterSize(4)); - - this->_registers._bgsc[0].tilemapAddress = 0x4000 >> 10U; - this->_registers._bgsc[1].tilemapAddress = 0x6000 >> 10U; - this->_backgrounds[0].setTileMapStartAddress(this->getTileMapStartAddress(1)); - this->_backgrounds[1].setTileMapStartAddress(this->getTileMapStartAddress(1)); - this->_backgrounds[2].setTileMapStartAddress(this->getTileMapStartAddress(2)); - this->_backgrounds[3].setTileMapStartAddress(this->getTileMapStartAddress(2)); - - //this->_registers._bgofs[2].raw = 0x03E0; - //this->_registers._bgofs[3].raw = 0x03DF; - this->_registers._t[0].enableWindowDisplayBg1 = true; - this->_registers._t[0].enableWindowDisplayBg2 = true; -/* - - //registers aladin - - this->_registers._bgmode.bgMode = 1; - this->_backgrounds[0].setBpp(this->getBPP(1)); - this->_backgrounds[1].setBpp(this->getBPP(1)); - this->_backgrounds[2].setBpp(this->getBPP(2)); - this->_backgrounds[3].setBpp(this->getBPP(2)); - this->_backgrounds[4].setBpp(this->getBPP(3)); - this->_backgrounds[5].setBpp(this->getBPP(3)); - //this->_registers._bgmode.characterSizeBg1 = false; - //this->_registers._bgmode.characterSizeBg2 = false; - this->_registers._bgmode.mode1Bg3PriorityBit = true; - this->_backgrounds[0].setCharacterSize(this->getCharacterSize(1)); - this->_backgrounds[1].setCharacterSize(this->getCharacterSize(1)); - this->_backgrounds[2].setCharacterSize(this->getCharacterSize(2)); - this->_backgrounds[3].setCharacterSize(this->getCharacterSize(2)); - - this->_registers._bgsc[0].tilemapAddress = 0x4800U >> 10U; // 0x4800 - this->_registers._bgsc[0].tilemapHorizontalMirroring = 1; - this->_registers._bgsc[1].tilemapAddress = 0x4000U >> 10U; // 0x4000 - this->_registers._bgsc[1].tilemapHorizontalMirroring = 1; - this->_registers._bgsc[2].tilemapAddress = 0x5C00U >> 10U; - this->_backgrounds[0].setTileMapStartAddress(this->getTileMapStartAddress(1)); - this->_backgrounds[0].setTilemaps(this->getBackgroundSize(1)); - this->_backgrounds[1].setTileMapStartAddress(this->getTileMapStartAddress(1)); - this->_backgrounds[1].setTilemaps(this->getBackgroundSize(1)); - this->_backgrounds[2].setTileMapStartAddress(this->getTileMapStartAddress(2)); - this->_backgrounds[2].setTilemaps(this->getBackgroundSize(2)); - this->_backgrounds[3].setTileMapStartAddress(this->getTileMapStartAddress(2)); - this->_backgrounds[3].setTilemaps(this->getBackgroundSize(2)); - this->_backgrounds[4].setTileMapStartAddress(this->getTileMapStartAddress(3)); - this->_backgrounds[5].setTileMapStartAddress(this->getTileMapStartAddress(3)); - - //registres bgnba - //this->_registers._bgnba[0].baseAddressBg1a3 = 0x5; - //this->_registers._bgnba[0].baseAddressBg2a4 = 0x5; - this->_registers._bgnba[1].baseAddressBg1a3 = 0x5; - - //this->_backgrounds[0].setTilesetAddress(this->getTilesetAddress(1)); - //this->_backgrounds[1].setTilesetAddress(this->getTilesetAddress(1)); - //this->_backgrounds[2].setTilesetAddress(this->getTilesetAddress(2)); - //this->_backgrounds[3].setTilesetAddress(this->getTilesetAddress(2)); - this->_backgrounds[4].setTilesetAddress(this->getTilesetAddress(3)); - this->_backgrounds[5].setTilesetAddress(this->getTilesetAddress(3)); - - this->_registers._vmain.incrementMode = true; - this->_registers._vmain.incrementAmount = 1; - - this->_registers._vmdata.vmdata = 0x1AF0; - - this->_registers._t[0].enableWindowDisplayBg1 = true; - this->_registers._t[0].enableWindowDisplayBg2 = true; - this->_registers._t[0].enableWindowDisplayBg3 = true; -*/ - } uint8_t PPU::read(uint24_t addr) @@ -471,16 +304,14 @@ namespace ComSquare::PPU this->add_buffer(this->_screen, this->_mainScreen); //this->_backgrounds[2].renderBackground(); //add_buffer(this->_screen, this->_backgrounds[2].buffer); - for (unsigned long i = 0; i < this->_screen.size(); i++) { - for (unsigned long j = 0; j < this->_screen[i].size(); j++) { + for (unsigned long i = 0; i < 1024; i++) { + for (unsigned long j = 0; j < 1024; j++) { this->_renderer.putPixel(j, i, this->_screen[i][j]); } } this->_renderer.drawScreen(); - for (auto &i : this->_mainScreen) - i.fill(0XFF); - for (auto &i : this->_subScreen) - i.fill(0XFF); + memset(this->_mainScreen, 0xFF, sizeof(this->_mainScreen)); + memset(this->_subScreen, 0xFF, sizeof(this->_subScreen)); } std::string PPU::getName() const @@ -720,8 +551,9 @@ namespace ComSquare::PPU colorPalette += this->cgram->read(1) << 8U; uint32_t color = Utils::getRealColor(colorPalette); - for (auto &row : this->_subScreen) - row.fill(color); + for (auto &array : this->_subScreen) + for (auto &c : array) + c = color; // the buffer is overwrite if necessary by a new bg so the background priority is from back to front // the starting palette index isn't implemented switch (this->_registers._bgmode.bgMode) { diff --git a/sources/PPU/PPU.hpp b/sources/PPU/PPU.hpp index 8b98746..a90bdd3 100644 --- a/sources/PPU/PPU.hpp +++ b/sources/PPU/PPU.hpp @@ -561,11 +561,11 @@ namespace ComSquare::PPU //! @brief Backgrounds buffers Background _backgrounds[8]; //! @brief Main Screen buffer - std::array, 1024> _mainScreen; + uint32_t _mainScreen[1024][1024]; //! @brief Sub Screen buffer - std::array, 1024> _subScreen; + uint32_t _subScreen[1024][1024]; //! @brief Final Screen buffer - std::array, 1024> _screen; + uint32_t _screen[1024][1024]; //! @brief Used for vram read registers (0x2139 - 0x213A) uint16_t _vramReadBuffer = 0; //! @brief Struct that contain all necessary vars for the use of the registers @@ -621,13 +621,13 @@ namespace ComSquare::PPU void renderMainAndSubScreen(); //! @brief Add a bg buffer to another buffer template - void add_buffer(std::array, DEST_SIZE_X> &bufferDest, - const std::array, SRC_SIZE_X> &bufferSrc, + void add_buffer(uint32_t (&bufferDest)[DEST_SIZE_Y][DEST_SIZE_X], + const uint32_t (&bufferSrc)[SRC_SIZE_Y][SRC_SIZE_X], const Vector2 &offset = {0, 0}) { // TODO use std::ranges - for (unsigned long i = 0; i < bufferSrc.size(); i++) { - for (unsigned long j = 0; j < bufferSrc[i].size(); j++) { + for (unsigned long i = 0; i < 1024; i++) { + for (unsigned long j = 0; j < 1024; j++) { if (bufferSrc[i][j] > 0xFF) // 0xFF correspond to a black pixel with full brightness bufferDest[i + offset.x ][j + offset.y] = bufferSrc[i][j]; } @@ -645,11 +645,10 @@ namespace ComSquare::PPU const Registers &getWriteRegisters() const; template - void add_buffer(const std::array, SRC_SIZE_X> &buffer, + void add_buffer(const uint32_t (&buffer)[SRC_SIZE_Y][SRC_SIZE_X], const Vector2 &offset = {0, 0}) { - for (auto &i : this->_screen) - i.fill(0XFF); +// memset(this->_screen, 0xFF, sizeof(this->_screen)); for (unsigned long i = 0; i < buffer.size(); i++) { for (unsigned long j = 0; j < buffer[i].size(); j++) { if (buffer[i][j] > 0xFF) // 0xFF correspond to a black pixel with full brightness diff --git a/sources/SNES.cpp b/sources/SNES.cpp index e8b585c..ca93f51 100644 --- a/sources/SNES.cpp +++ b/sources/SNES.cpp @@ -3,6 +3,7 @@ // #include +#include #include "SNES.hpp" #ifdef DEBUGGER_ENABLED #include "Debugger/CPU/CPUDebug.hpp" @@ -16,12 +17,12 @@ namespace ComSquare { SNES::SNES(const std::string &romPath, Renderer::IRenderer &renderer) : bus(std::make_shared()), - cartridge(new Cartridge::Cartridge(romPath)), - wram(new Ram::Ram(16384, WRam, "WRam")), - sram(new Ram::Ram(this->cartridge->header.sramSize, SRam, "SRam")), - cpu(new CPU::CPU(this->bus, cartridge->header)), - ppu(new PPU::PPU(renderer)), - apu(new APU::APU(renderer)) + cartridge(std::make_shared(romPath)), + wram(std::make_shared(16384, WRam, "WRam")), + sram(std::make_shared(this->cartridge->header.sramSize, SRam, "SRam")), + cpu(std::make_shared(this->bus, cartridge->header)), + ppu(std::make_shared(renderer)), + apu(std::make_shared(renderer)) { this->bus->mapComponents(*this); if (this->cartridge->getType() == Cartridge::Audio) diff --git a/tests/APU/testAPU.cpp b/tests/APU/testAPU.cpp index 767beb5..8f1a8e4 100644 --- a/tests/APU/testAPU.cpp +++ b/tests/APU/testAPU.cpp @@ -2,12 +2,12 @@ // Created by Melefo on 12/02/2020. // -#include +#include #include "../tests.hpp" -#include "../../sources/SNES.hpp" -#include "../../sources/APU/APU.hpp" -#include "../../sources/Exceptions/InvalidAddress.hpp" -#include "../../sources/Exceptions/InvalidOpcode.hpp" +#include "SNES.hpp" +#include "APU/APU.hpp" +#include "Exceptions/InvalidAddress.hpp" +#include "Exceptions/InvalidOpcode.hpp" using namespace ComSquare; @@ -17,17 +17,17 @@ using namespace ComSquare; // // ////////////////////////////// -Test(_internalRead, register) +TEST_CASE("register internalRead", "[internalRead]") { Init() auto apu = snes.apu;int8_t result = 0; apu->_registers.counter0 = 123; result = apu->_internalRead(0x00FD); - cr_assert_eq(result, 123); + REQUIRE(result == 123); } -Test(_internalRead, Page0) +TEST_CASE("Page0 read Read", "[Read]") { Init() auto apu = snes.apu; @@ -35,10 +35,10 @@ Test(_internalRead, Page0) apu->_map->Page0._data[0x0010] = 123; result = apu->_internalRead(0x0010); - cr_assert_eq(result, 123); + REQUIRE(result == 123); } -Test(_internalRead, Page1) +TEST_CASE("Page1 read Read", "[Read]") { Init() auto apu = snes.apu; @@ -46,10 +46,10 @@ Test(_internalRead, Page1) apu->_map->Page1._data[0x0042] = 123; result = apu->_internalRead(0x0142); - cr_assert_eq(result, 123); + REQUIRE(result == 123); } -Test(_internalRead, Memory) +TEST_CASE("Memory internalRead", "[internalRead]") { Init() auto apu = snes.apu; @@ -57,10 +57,10 @@ Test(_internalRead, Memory) apu->_map->Memory._data[0xFCDC] = 123; result = apu->_internalRead(0xFEDC); - cr_assert_eq(result, 123); + REQUIRE(result == 123); } -Test(_internalRead, IPL) +TEST_CASE("IPL internalRead", "[internalRead]") { Init() auto apu = snes.apu; @@ -68,15 +68,15 @@ Test(_internalRead, IPL) apu->_map->IPL._data[0x001F] = 123; result = apu->_internalRead(0xFFDF); - cr_assert_eq(result, 123); + REQUIRE(result == 123); } -Test(_internalRead, Invalid) +TEST_CASE("Invalid internalRead", "[internalRead]") { Init() auto apu = snes.apu; - cr_assert_throw(apu->_internalRead(0x10000), InvalidAddress); + REQUIRE_THROWS_AS(apu->_internalRead(0x10000), InvalidAddress); } /////////////////////////////// @@ -85,57 +85,57 @@ Test(_internalRead, Invalid) // // /////////////////////////////// -Test(_internalWrite, Page0) +TEST_CASE("Page0 write Write", "[Write]") { Init() auto apu = snes.apu; apu->_internalWrite(0x0001, 123); - cr_assert_eq(apu->_map->Page0._data[0x0001], 123); + REQUIRE(apu->_map->Page0._data[0x0001] == 123); } -Test(_internalWrite, register) +TEST_CASE("register write Write", "[Write]") { Init() auto apu = snes.apu; apu->_internalWrite(0x00F4, 123); - cr_assert_eq(apu->_registers.port0, 123); + REQUIRE(apu->_registers.port0 == 123); } -Test(_internalWrite, Page1) +TEST_CASE("Page1 internalWrite", "[internalWrite]") { Init() auto apu = snes.apu; apu->_internalWrite(0x01FF, 123); - cr_assert_eq(apu->_map->Page1._data[0x00FF], 123); + REQUIRE(apu->_map->Page1._data[0x00FF] == 123); } -Test(_internalWrite, Memory) +TEST_CASE("Memory write internalWrite", "[internalWrite]") { Init() auto apu = snes.apu; apu->_internalWrite(0x0789, 123); - cr_assert_eq(apu->_map->Memory._data[0x0589], 123); + REQUIRE(apu->_map->Memory._data[0x0589] == 123); } -Test(_internalWrite, IPL) +TEST_CASE("IPL internalWrite", "[internalWrite]") { Init() auto apu = snes.apu; apu->_internalWrite(0xFFF0, 123); - cr_assert_eq(apu->_map->IPL._data[0x0030], 123); + REQUIRE(apu->_map->IPL._data[0x0030] == 123); } -Test(_internalWrite, Invalid) +TEST_CASE("Invalid internalWrite", "[internalWrite]") { Init() auto apu = snes.apu; - cr_assert_throw(apu->_internalWrite(0x10000, 123), InvalidAddress); + REQUIRE_THROWS_AS(apu->_internalWrite(0x10000, 123), InvalidAddress); } ///////////////////// @@ -144,7 +144,7 @@ Test(_internalWrite, Invalid) // // ///////////////////// -Test(read, Valid) +TEST_CASE("Valid read", "[read]") { Init() auto apu = snes.apu; @@ -152,15 +152,15 @@ Test(read, Valid) apu->_registers.port2 = 123; result = apu->read(0x02); - cr_assert_eq(result, 123); + REQUIRE(result == 123); } -Test(read, Invalid) +TEST_CASE("Invalid read", "[read]") { Init() auto apu = snes.apu; - cr_assert_throw(apu->read(0x10000), InvalidAddress); + REQUIRE_THROWS_AS(apu->read(0x10000), InvalidAddress); } ////////////////////// @@ -169,21 +169,21 @@ Test(read, Invalid) // // ////////////////////// -Test(write, Valid) +TEST_CASE("Valid write", "[write]") { Init() auto apu = snes.apu; apu->write(0x03, 123); - cr_assert_eq(apu->_registers.port3, 123); + REQUIRE(apu->_registers.port3 == 123); } -Test(write, Invalid) +TEST_CASE("Invalid write", "[write]") { Init() auto apu = snes.apu; - cr_assert_throw(apu->write(0x04, 123), InvalidAddress); + REQUIRE_THROWS_AS(apu->write(0x04, 123), InvalidAddress); } /////////////////////////////////// @@ -192,7 +192,7 @@ Test(write, Invalid) // // /////////////////////////////////// -Test(executeInstruction, Valid) +TEST_CASE("Valid executeInstruction", "[executeInstruction]") { Init() auto apu = snes.apu; @@ -200,7 +200,7 @@ Test(executeInstruction, Valid) apu->_internalRegisters.pc = 0x00; result = apu->_executeInstruction(); - cr_assert_eq(result, 2); + REQUIRE(result == 2); } /////////////////////// @@ -209,24 +209,24 @@ Test(executeInstruction, Valid) // // /////////////////////// -Test(update, running) +TEST_CASE("running update", "[update]") { Init() auto apu = snes.apu; apu->_internalRegisters.pc = 0x00; apu->update(1); - cr_assert_eq(apu->_paddingCycles, 1); + REQUIRE(apu->_paddingCycles == 1); } -Test(update, stopped) +TEST_CASE("stopped update", "[update]") { Init() auto apu = snes.apu; apu->_state = APU::Stopped; apu->update(1); - cr_assert_eq(apu->_paddingCycles, 0); + REQUIRE(apu->_paddingCycles == 0); } ////////////////////////// @@ -235,17 +235,17 @@ Test(update, stopped) // // ////////////////////////// -Test(_get, direct) +TEST_CASE("direct get", "[get]") { Init() auto apu = snes.apu; apu->_internalRegisters.pc = 0x32; apu->_internalWrite(0x32, 123); - cr_assert_eq(apu->_getDirectAddr(), 123); + REQUIRE(apu->_getDirectAddr() == 123); } -Test(_get, absolute) +TEST_CASE("absolute get", "[get]") { Init() auto apu = snes.apu; @@ -253,5 +253,5 @@ Test(_get, absolute) apu->_internalRegisters.pc = 0x32; apu->_internalWrite(0x32, 0b00001111); apu->_internalWrite(0x33, 0b11110000); - cr_assert_eq(apu->_getAbsoluteAddr(), 61455); + REQUIRE(apu->_getAbsoluteAddr() == 61455); } \ No newline at end of file diff --git a/tests/APU/testAPUInstructions.cpp b/tests/APU/testAPUInstructions.cpp index 1f47f26..4fb9697 100644 --- a/tests/APU/testAPUInstructions.cpp +++ b/tests/APU/testAPUInstructions.cpp @@ -2,7 +2,7 @@ // Created by Melefo on 11/02/2020. // -#include +#include #include #include #include "../tests.hpp" @@ -18,36 +18,36 @@ using namespace ComSquare; // // //////////////////// -Test(Standbys, NOP) +TEST_CASE("NOP Standbys", "[Standbys]") { Init() auto apu = snes.apu; int result = 0; result = apu->NOP(); - cr_assert_eq(result, 2); + REQUIRE(result == 2); } -Test(Standbys, SLEEP) +TEST_CASE("SLEEP Standbys", "[Standbys]") { Init() auto apu = snes.apu; int result = 0; result = apu->SLEEP(); - cr_assert_eq(result, 3); - cr_assert_eq(apu->_state, APU::Sleeping); + REQUIRE(result == 3); + REQUIRE(apu->_state == APU::Sleeping); } -Test(Standbys, STOP) +TEST_CASE("STOP Standbys", "[Standbys]") { Init() auto apu = snes.apu; int result = 0; result = apu->STOP(); - cr_assert_eq(result, 3); - cr_assert_eq(apu->_state, APU::Stopped); + REQUIRE(result == 3); + REQUIRE(apu->_state == APU::Stopped); } /////////////// @@ -56,29 +56,29 @@ Test(Standbys, STOP) // // /////////////// -Test(PSW, CLRC) +TEST_CASE("CLRC PSW", "[PSW]") { Init() auto apu = snes.apu; int result = 0; result = apu->CLRC(); - cr_assert_eq(result, 2); - cr_assert_eq(apu->_internalRegisters.c, false); + REQUIRE(result == 2); + REQUIRE(apu->_internalRegisters.c == false); } -Test(PSW, SETC) +TEST_CASE("SETC PSW", "[PSW]") { Init() auto apu = snes.apu; int result = 0; result = apu->SETC(); - cr_assert_eq(result, 2); - cr_assert_eq(apu->_internalRegisters.c, true); + REQUIRE(result == 2); + REQUIRE(apu->_internalRegisters.c == true); } -Test(PSW, NOTC) +TEST_CASE("NOTC PSW", "[PSW]") { Init() auto apu = snes.apu; @@ -86,64 +86,64 @@ Test(PSW, NOTC) apu->_internalRegisters.c = false; result = apu->NOTC(); - cr_assert_eq(result, 3); - cr_assert_eq(apu->_internalRegisters.c, true); + REQUIRE(result == 3); + REQUIRE(apu->_internalRegisters.c == true); } -Test(PSW, CLRV) +TEST_CASE("CLRV PSW", "[PSW]") { Init() auto apu = snes.apu; int result = 0; result = apu->CLRV(); - cr_assert_eq(result, 2); - cr_assert_eq(apu->_internalRegisters.v, false); - cr_assert_eq(apu->_internalRegisters.h, false); + REQUIRE(result == 2); + REQUIRE(apu->_internalRegisters.v == false); + REQUIRE(apu->_internalRegisters.h == false); } -Test(PSW, CLRP) +TEST_CASE("CLRP PSW", "[PSW]") { Init() auto apu = snes.apu; int result = 0; result = apu->CLRP(); - cr_assert_eq(result, 2); - cr_assert_eq(apu->_internalRegisters.p, false); + REQUIRE(result == 2); + REQUIRE(apu->_internalRegisters.p == false); } -Test(PSW, SETP) +TEST_CASE("SETP PSW", "[PSW]") { Init() auto apu = snes.apu; int result = 0; result = apu->SETP(); - cr_assert_eq(result, 2); - cr_assert_eq(apu->_internalRegisters.p, true); + REQUIRE(result == 2); + REQUIRE(apu->_internalRegisters.p == true); } -Test(PSW, EI) +TEST_CASE("EI PSW", "[PSW]") { Init() auto apu = snes.apu; int result = 0; result = apu->EI(); - cr_assert_eq(result, 3); - cr_assert_eq(apu->_internalRegisters.i, true); + REQUIRE(result == 3); + REQUIRE(apu->_internalRegisters.i == true); } -Test(PSW, DI) +TEST_CASE("DI PSW", "[PSW]") { Init() auto apu = snes.apu; int result = 0; result = apu->DI(); - cr_assert_eq(result, 3); - cr_assert_eq(apu->_internalRegisters.i, false); + REQUIRE(result == 3); + REQUIRE(apu->_internalRegisters.i == false); } /////////////// @@ -152,7 +152,7 @@ Test(PSW, DI) // // /////////////// -Test(Bit, SET1) +TEST_CASE("SET1 Bit", "[Bit]") { Init() auto apu = snes.apu; @@ -163,11 +163,11 @@ Test(Bit, SET1) apu->_internalRegisters.pc--; result = apu->SET1(apu->_getDirectAddr(), 0); apu->_internalRegisters.pc--; - cr_assert_eq(result, 4); - cr_assert_eq(apu->_internalRead(apu->_getDirectAddr()), 1); + REQUIRE(result == 4); + REQUIRE(apu->_internalRead(apu->_getDirectAddr()) == 1); } -Test(Bit, CLR1) +TEST_CASE("CLR1 Bit", "[Bit]") { Init() auto apu = snes.apu; @@ -178,11 +178,11 @@ Test(Bit, CLR1) apu->_internalRegisters.pc--; result = apu->CLR1(apu->_getDirectAddr(), 0); apu->_internalRegisters.pc--; - cr_assert_eq(result, 4); - cr_assert_eq(apu->_internalRead(apu->_getDirectAddr()), 0b11111110); + REQUIRE(result == 4); + REQUIRE(apu->_internalRead(apu->_getDirectAddr()) == 0b11111110); } -Test(Bit, TSET1) +TEST_CASE("TSET1 Bit", "[Bit]") { Init() auto apu = snes.apu; @@ -196,11 +196,11 @@ Test(Bit, TSET1) apu->_internalRegisters.pc -= 2; result = apu->TSET1(apu->_getAbsoluteAddr()); apu->_internalRegisters.pc -= 2; - cr_assert_eq(apu->_internalRead(apu->_getAbsoluteAddr()), 0x7B); - cr_assert_eq(result, 6); + REQUIRE(apu->_internalRead(apu->_getAbsoluteAddr()) == 0x7B); + REQUIRE(result == 6); } -Test(Bit, TCLR1) +TEST_CASE("TCLR1 Bit", "[Bit]") { Init() auto apu = snes.apu; @@ -214,11 +214,11 @@ Test(Bit, TCLR1) apu->_internalRegisters.pc -= 2; result = apu->TCLR1(apu->_getAbsoluteAddr()); apu->_internalRegisters.pc -= 2; - cr_assert_eq(apu->_internalRead(apu->_getAbsoluteAddr()), 0x00); - cr_assert_eq(result, 6); + REQUIRE(apu->_internalRead(apu->_getAbsoluteAddr()) == 0x00); + REQUIRE(result == 6); } -Test(Bit, AND1) +TEST_CASE("AND1 Bit", "[Bit]") { Init() auto apu = snes.apu; @@ -232,11 +232,11 @@ Test(Bit, AND1) apu->_internalRegisters.pc -= 2; result = apu->AND1(apu->_getAbsoluteBit()); apu->_internalRegisters.pc -= 2; - cr_assert_eq(apu->_internalRegisters.c, false); - cr_assert_eq(result, 4); + REQUIRE(apu->_internalRegisters.c == false); + REQUIRE(result == 4); } -Test(Bit, AND1_invert) +TEST_CASE("AND1_invert Bit", "[Bit]") { Init() auto apu = snes.apu; @@ -250,11 +250,11 @@ Test(Bit, AND1_invert) apu->_internalRegisters.pc -= 2; result = apu->AND1(apu->_getAbsoluteBit(), true); apu->_internalRegisters.pc -= 2; - cr_assert_eq(apu->_internalRegisters.c, false); - cr_assert_eq(result, 4); + REQUIRE(apu->_internalRegisters.c == false); + REQUIRE(result == 4); } -Test(Bit, OR1) +TEST_CASE("OR1 Bit", "[Bit]") { Init() auto apu = snes.apu; @@ -268,11 +268,11 @@ Test(Bit, OR1) apu->_internalRegisters.pc -= 2; result = apu->OR1(apu->_getAbsoluteBit()); apu->_internalRegisters.pc -= 2; - cr_assert_eq(apu->_internalRegisters.c, false); - cr_assert_eq(result, 5); + REQUIRE(apu->_internalRegisters.c == false); + REQUIRE(result == 5); } -Test(Bit, OR1_invert) +TEST_CASE("OR1_invert Bit", "[Bit]") { Init() auto apu = snes.apu; @@ -286,11 +286,11 @@ Test(Bit, OR1_invert) apu->_internalRegisters.pc -= 2; result = apu->OR1(apu->_getAbsoluteBit(), true); apu->_internalRegisters.pc -= 2; - cr_assert_eq(apu->_internalRegisters.c, true); - cr_assert_eq(result, 5); + REQUIRE(apu->_internalRegisters.c == true); + REQUIRE(result == 5); } -Test(Bit, EOR1) +TEST_CASE("EOR1 Bit", "[Bit]") { Init() auto apu = snes.apu; @@ -304,11 +304,11 @@ Test(Bit, EOR1) apu->_internalRegisters.pc -= 2; result = apu->EOR1(apu->_getAbsoluteBit()); apu->_internalRegisters.pc -= 2; - cr_assert_eq(apu->_internalRegisters.c, false); - cr_assert_eq(result, 5); + REQUIRE(apu->_internalRegisters.c == false); + REQUIRE(result == 5); } -Test(Bit, NOT1) +TEST_CASE("NOT1 Bit", "[Bit]") { Init() auto apu = snes.apu; @@ -322,11 +322,11 @@ Test(Bit, NOT1) apu->_internalRegisters.pc -= 2; result = apu->NOT1(apu->_getAbsoluteBit()); apu->_internalRegisters.pc -= 2; - cr_assert_eq(apu->_internalRegisters.c, false); - cr_assert_eq(result, 5); + REQUIRE(apu->_internalRegisters.c == false); + REQUIRE(result == 5); } -Test(Bit, MOV1) +TEST_CASE("MOV1 Bit", "[Bit]") { Init() auto apu = snes.apu; @@ -340,11 +340,11 @@ Test(Bit, MOV1) apu->_internalRegisters.pc -= 2; result = apu->MOV1(apu->_getAbsoluteBit()); apu->_internalRegisters.pc -= 2; - cr_assert_eq(apu->_internalRead(apu->_getAbsoluteAddr() & 0x1FFFu), 123); - cr_assert_eq(result, 6); + REQUIRE(apu->_internalRead(apu->_getAbsoluteAddr() & 0x1FFFu) == 123); + REQUIRE(result == 6); } -Test(Bit, MOV1_carry) +TEST_CASE("MOV1_carry Bit", "[Bit]") { Init() auto apu = snes.apu; @@ -358,8 +358,8 @@ Test(Bit, MOV1_carry) apu->_internalRegisters.pc -= 2; result = apu->MOV1(apu->_getAbsoluteBit(), true); apu->_internalRegisters.pc -= 2; - cr_assert_eq(apu->_internalRegisters.c, false); - cr_assert_eq(result, 4); + REQUIRE(apu->_internalRegisters.c == false); + REQUIRE(result == 4); } ///////////////// @@ -368,7 +368,7 @@ Test(Bit, MOV1_carry) // // ///////////////// -Test(Stack, PUSH) +TEST_CASE("PUSH Stack", "[Stack]") { Init() auto apu = snes.apu; @@ -377,11 +377,11 @@ Test(Stack, PUSH) apu->_internalRegisters.a = 56; result = apu->PUSH(apu->_internalRegisters.a); apu->_internalRegisters.sp++; - cr_assert_eq(result, 4); - cr_assert_eq(apu->_internalRead(apu->_internalRegisters.sp | 0x100u), 56); + REQUIRE(result == 4); + REQUIRE(apu->_internalRead(apu->_internalRegisters.sp | 0x100u) == 56); } -Test(Stack, POP) +TEST_CASE("POP Stack", "[Stack]") { Init() auto apu = snes.apu; @@ -390,8 +390,8 @@ Test(Stack, POP) apu->_internalWrite(++apu->_internalRegisters.sp | 0x100u, 82); apu->_internalRegisters.sp--; result = apu->POP(apu->_internalRegisters.y); - cr_assert_eq(result, 4); - cr_assert_eq(apu->_internalRegisters.y, 82); + REQUIRE(result == 4); + REQUIRE(apu->_internalRegisters.y == 82); } ////////////////////// @@ -400,7 +400,7 @@ Test(Stack, POP) // // ////////////////////// -Test(Subroutine, CALL) +TEST_CASE("CALL Subroutine", "[Subroutine]") { Init() auto apu = snes.apu; @@ -410,13 +410,13 @@ Test(Subroutine, CALL) apu->_internalWrite(apu->_getAbsoluteAddr(), 23); apu->_internalRegisters.pc -= 2; result = apu->CALL(apu->_getAbsoluteAddr()); - cr_assert_eq(result, 8); - cr_assert_eq(apu->_internalRegisters.pc, 23); - cr_assert_eq(apu->_internalRead(++apu->_internalRegisters.sp + 0x0100u), 2); - cr_assert_eq(apu->_internalRead(++apu->_internalRegisters.sp + 0x0100u), 0); + REQUIRE(result == 8); + REQUIRE(apu->_internalRegisters.pc == 23); + REQUIRE(apu->_internalRead(++apu->_internalRegisters.sp + 0x0100u) == 2); + REQUIRE(apu->_internalRead(++apu->_internalRegisters.sp + 0x0100u) == 0); } -Test(Subroutine, PCALL) +TEST_CASE("PCALL Subroutine", "[Subroutine]") { Init() auto apu = snes.apu; @@ -424,11 +424,11 @@ Test(Subroutine, PCALL) apu->_internalWrite(apu->_internalRegisters.pc, 123); result = apu->PCALL(); - cr_assert_eq(result, 6); - cr_assert_eq(apu->_internalRegisters.pc, 65403); + REQUIRE(result == 6); + REQUIRE(apu->_internalRegisters.pc == 65403); } -Test(Subroutine, TCALL) +TEST_CASE("TCALL Subroutine", "[Subroutine]") { Init() auto apu = snes.apu; @@ -436,11 +436,11 @@ Test(Subroutine, TCALL) apu->_internalWrite(0xFFD0, 45); result = apu->TCALL(7); - cr_assert_eq(result, 8); - cr_assert_eq(apu->_internalRegisters.pc, 45); + REQUIRE(result == 8); + REQUIRE(apu->_internalRegisters.pc == 45); } -Test(Subroutine, BRK) +TEST_CASE("BRK Subroutine", "[Subroutine]") { Init() auto apu = snes.apu; @@ -453,16 +453,16 @@ Test(Subroutine, BRK) apu->_internalWrite(0xFFDE, 0xBB); result = apu->BRK(); apu->_internalRegisters.sp += 3; - cr_assert_eq(result, 8); - cr_assert_eq(apu->_internalRegisters.i, false); - cr_assert_eq(apu->_internalRegisters.b, true); - cr_assert_eq(apu->_internalRegisters.pc, 0xAABB); - cr_assert_eq(apu->_internalRead(apu->_internalRegisters.sp-- | 0x100u), 0xFF); - cr_assert_eq(apu->_internalRead(apu->_internalRegisters.sp-- | 0x100u), 0xEE); - cr_assert_eq(apu->_internalRead(apu->_internalRegisters.sp | 0x100u), 0xDD); + REQUIRE(result == 8); + REQUIRE(apu->_internalRegisters.i == false); + REQUIRE(apu->_internalRegisters.b == true); + REQUIRE(apu->_internalRegisters.pc == 0xAABB); + REQUIRE(apu->_internalRead(apu->_internalRegisters.sp-- | 0x100u) == 0xFF); + REQUIRE(apu->_internalRead(apu->_internalRegisters.sp-- | 0x100u) == 0xEE); + REQUIRE(apu->_internalRead(apu->_internalRegisters.sp | 0x100u) == 0xDD); } -Test(Subroutine, RET) +TEST_CASE("RET Subroutine", "[Subroutine]") { Init() auto apu = snes.apu; @@ -472,12 +472,12 @@ Test(Subroutine, RET) apu->_internalWrite(++apu->_internalRegisters.sp | 0x100u, 0x34); apu->_internalRegisters.sp -= 2; result = apu->RET(); - cr_assert_eq(result, 5); - cr_assert_eq(apu->_internalRegisters.pch, 0x12); - cr_assert_eq(apu->_internalRegisters.pcl, 0x34); + REQUIRE(result == 5); + REQUIRE(apu->_internalRegisters.pch == 0x12); + REQUIRE(apu->_internalRegisters.pcl == 0x34); } -Test(Subroutine, RETI) +TEST_CASE("RETI Subroutine", "[Subroutine]") { Init() auto apu = snes.apu; @@ -488,10 +488,10 @@ Test(Subroutine, RETI) apu->_internalWrite(++apu->_internalRegisters.sp | 0x100u, 0x56); apu->_internalRegisters.sp -= 3; result = apu->RETI(); - cr_assert_eq(result, 6); - cr_assert_eq(apu->_internalRegisters.psw, 0x12); - cr_assert_eq(apu->_internalRegisters.pch, 0x34); - cr_assert_eq(apu->_internalRegisters.pcl, 0x56); + REQUIRE(result == 6); + REQUIRE(apu->_internalRegisters.psw == 0x12); + REQUIRE(apu->_internalRegisters.pch == 0x34); + REQUIRE(apu->_internalRegisters.pcl == 0x56); } //////////////////////// @@ -500,7 +500,7 @@ Test(Subroutine, RETI) // // //////////////////////// -Test(ProgramFlow, BRA) +TEST_CASE("BRA ProgramFlow", "[ProgramFlow]") { Init() auto apu = snes.apu; @@ -509,11 +509,11 @@ Test(ProgramFlow, BRA) apu->_internalRegisters.pc = 0; apu->_internalWrite(apu->_internalRegisters.pc, 23); result = apu->BRA(apu->_getImmediateData()); - cr_assert_eq(result, 4); - cr_assert_eq(apu->_internalRegisters.pc, 24); + REQUIRE(result == 4); + REQUIRE(apu->_internalRegisters.pc == 24); } -Test(ProgramFlow, BEQ) +TEST_CASE("BEQ ProgramFlow", "[ProgramFlow]") { Init() auto apu = snes.apu; @@ -522,14 +522,14 @@ Test(ProgramFlow, BEQ) apu->_internalRegisters.pc = 0; apu->_internalWrite(apu->_internalRegisters.pc + 1, 23); result = apu->BEQ(apu->_getImmediateData()); - cr_assert_eq(result, 2); + REQUIRE(result == 2); apu->_internalRegisters.z = true; result = apu->BEQ(apu->_getImmediateData()); - cr_assert_eq(result, 4); - cr_assert_eq(apu->_internalRegisters.pc, 25); + REQUIRE(result == 4); + REQUIRE(apu->_internalRegisters.pc == 25); } -Test(ProgramFlow, BNE) +TEST_CASE("BNE ProgramFlow", "[ProgramFlow]") { Init() auto apu = snes.apu; @@ -539,14 +539,14 @@ Test(ProgramFlow, BNE) apu->_internalWrite(apu->_internalRegisters.pc + 1, 23); apu->_internalRegisters.z = true; result = apu->BNE(apu->_getImmediateData()); - cr_assert_eq(result, 2); + REQUIRE(result == 2); apu->_internalRegisters.z = false; result = apu->BNE(apu->_getImmediateData()); - cr_assert_eq(result, 4); - cr_assert_eq(apu->_internalRegisters.pc, 25); + REQUIRE(result == 4); + REQUIRE(apu->_internalRegisters.pc == 25); } -Test(ProgramFlow, BCS) +TEST_CASE("BCS ProgramFlow", "[ProgramFlow]") { Init() auto apu = snes.apu; @@ -555,14 +555,14 @@ Test(ProgramFlow, BCS) apu->_internalRegisters.pc = 0; apu->_internalWrite(apu->_internalRegisters.pc + 1, 23); result = apu->BCS(apu->_getImmediateData()); - cr_assert_eq(result, 2); + REQUIRE(result == 2); apu->_internalRegisters.c = true; result = apu->BCS(apu->_getImmediateData()); - cr_assert_eq(result, 4); - cr_assert_eq(apu->_internalRegisters.pc, 25); + REQUIRE(result == 4); + REQUIRE(apu->_internalRegisters.pc == 25); } -Test(ProgramFlow, BCC) +TEST_CASE("BCC ProgramFlow", "[ProgramFlow]") { Init() auto apu = snes.apu; @@ -572,14 +572,14 @@ Test(ProgramFlow, BCC) apu->_internalWrite(apu->_internalRegisters.pc + 1, 23); apu->_internalRegisters.c = true; result = apu->BCC(apu->_getImmediateData()); - cr_assert_eq(result, 2); + REQUIRE(result == 2); apu->_internalRegisters.c = false; result = apu->BCC(apu->_getImmediateData()); - cr_assert_eq(result, 4); - cr_assert_eq(apu->_internalRegisters.pc, 25); + REQUIRE(result == 4); + REQUIRE(apu->_internalRegisters.pc == 25); } -Test(ProgramFlow, BVS) +TEST_CASE("BVS ProgramFlow", "[ProgramFlow]") { Init() auto apu = snes.apu; @@ -588,14 +588,14 @@ Test(ProgramFlow, BVS) apu->_internalRegisters.pc = 0; apu->_internalWrite(apu->_internalRegisters.pc + 1, 23); result = apu->BVS(apu->_getImmediateData()); - cr_assert_eq(result, 2); + REQUIRE(result == 2); apu->_internalRegisters.v = true; result = apu->BVS(apu->_getImmediateData()); - cr_assert_eq(result, 4); - cr_assert_eq(apu->_internalRegisters.pc, 25); + REQUIRE(result == 4); + REQUIRE(apu->_internalRegisters.pc == 25); } -Test(ProgramFlow, BVC) +TEST_CASE("BVC ProgramFlow", "[ProgramFlow]") { Init() auto apu = snes.apu; @@ -605,14 +605,14 @@ Test(ProgramFlow, BVC) apu->_internalWrite(apu->_internalRegisters.pc + 1, 23); apu->_internalRegisters.v = true; result = apu->BVC(apu->_getImmediateData()); - cr_assert_eq(result, 2); + REQUIRE(result == 2); apu->_internalRegisters.v = false; result = apu->BVC(apu->_getImmediateData()); - cr_assert_eq(result, 4); - cr_assert_eq(apu->_internalRegisters.pc, 25); + REQUIRE(result == 4); + REQUIRE(apu->_internalRegisters.pc == 25); } -Test(ProgramFlow, BMI) +TEST_CASE("BMI ProgramFlow", "[ProgramFlow]") { Init() auto apu = snes.apu; @@ -621,14 +621,14 @@ Test(ProgramFlow, BMI) apu->_internalRegisters.pc = 0; apu->_internalWrite(apu->_internalRegisters.pc + 1, 23); result = apu->BMI(apu->_getImmediateData()); - cr_assert_eq(result, 2); + REQUIRE(result == 2); apu->_internalRegisters.n = true; result = apu->BMI(apu->_getImmediateData()); - cr_assert_eq(result, 4); - cr_assert_eq(apu->_internalRegisters.pc, 25); + REQUIRE(result == 4); + REQUIRE(apu->_internalRegisters.pc == 25); } -Test(ProgramFlow, BPL) +TEST_CASE("BPL ProgramFlow", "[ProgramFlow]") { Init() auto apu = snes.apu; @@ -638,14 +638,14 @@ Test(ProgramFlow, BPL) apu->_internalWrite(apu->_internalRegisters.pc + 1, 23); apu->_internalRegisters.n = true; result = apu->BPL(apu->_getImmediateData()); - cr_assert_eq(result, 2); + REQUIRE(result == 2); apu->_internalRegisters.n = false; result = apu->BPL(apu->_getImmediateData()); - cr_assert_eq(result, 4); - cr_assert_eq(apu->_internalRegisters.pc, 25); + REQUIRE(result == 4); + REQUIRE(apu->_internalRegisters.pc == 25); } -Test(ProgramFlow, BBS) +TEST_CASE("BBS ProgramFlow", "[ProgramFlow]") { Init() auto apu = snes.apu; @@ -655,16 +655,16 @@ Test(ProgramFlow, BBS) apu->_internalWrite(apu->_internalRegisters.pc + 1, 23); apu->_internalWrite(23, 0); result = apu->BBS(apu->_getDirectAddr(), apu->_getImmediateData(), 2); - cr_assert_eq(result, 5); + REQUIRE(result == 5); apu->_internalRegisters.pc = 0; apu->_internalWrite(apu->_internalRegisters.pc, 10); apu->_internalWrite(23, 100); result = apu->BBS(apu->_getDirectAddr(), apu->_getImmediateData(), 2); - cr_assert_eq(result, 7); - cr_assert_eq(apu->_internalRegisters.pc, 12); + REQUIRE(result == 7); + REQUIRE(apu->_internalRegisters.pc == 12); } -Test(ProgramFlow, BBC) +TEST_CASE("BBC ProgramFlow", "[ProgramFlow]") { Init() auto apu = snes.apu; @@ -674,16 +674,16 @@ Test(ProgramFlow, BBC) apu->_internalWrite(apu->_internalRegisters.pc + 1, 10); apu->_internalWrite(10, 255); result = apu->BBC(apu->_getDirectAddr(), apu->_getImmediateData(), 2); - cr_assert_eq(result, 5); + REQUIRE(result == 5); apu->_internalRegisters.pc = 0; apu->_internalWrite(apu->_internalRegisters.pc, 10); apu->_internalWrite(apu->_internalRegisters.pc + 1, 0); result = apu->BBC(apu->_getDirectAddr(), apu->_getImmediateData(), 2); - cr_assert_eq(result, 7); - cr_assert_eq(apu->_internalRegisters.pc, 12); + REQUIRE(result == 7); + REQUIRE(apu->_internalRegisters.pc == 12); } -Test(ProgramFlow, CBNE) +TEST_CASE("CBNE ProgramFlow", "[ProgramFlow]") { Init() auto apu = snes.apu; @@ -694,16 +694,16 @@ Test(ProgramFlow, CBNE) apu->_internalWrite(apu->_internalRegisters.pc + 1, 10); apu->_internalWrite(10, 4); result = apu->CBNE(apu->_getDirectAddr(), apu->_getImmediateData()); - cr_assert_eq(result, 5); + REQUIRE(result == 5); apu->_internalRegisters.pc = 0; apu->_internalRegisters.a = 0; apu->_internalWrite(apu->_internalRegisters.pc, 10); result = apu->CBNE(apu->_getDirectAddrByX(), apu->_getImmediateData(), true); - cr_assert_eq(result, 8); - cr_assert_eq(apu->_internalRegisters.pc, 12); + REQUIRE(result == 8); + REQUIRE(apu->_internalRegisters.pc == 12); } -Test(ProgramFlow, DBNZ) +TEST_CASE("DBNZ ProgramFlow", "[ProgramFlow]") { Init() auto apu = snes.apu; @@ -712,17 +712,17 @@ Test(ProgramFlow, DBNZ) apu->_internalRegisters.pc = 0; apu->_internalRegisters.y = 1; result = apu->DBNZ(apu->_getImmediateData()); - cr_assert_eq(result, 4); + REQUIRE(result == 4); apu->_internalWrite(apu->_internalRegisters.pc, 10); apu->_internalWrite(apu->_internalRegisters.pc + 1, 5); apu->_internalWrite(5, 55); result = apu->DBNZ(apu->_getImmediateData(), true); - cr_assert_eq(result, 7); - cr_assert_eq( apu->_internalRead(5), 54); - cr_assert_eq(apu->_internalRegisters.pc, 13); + REQUIRE(result == 7); + REQUIRE( apu->_internalRead(5) == 54); + REQUIRE(apu->_internalRegisters.pc == 13); } -Test(ProgramFlow, JMP) +TEST_CASE("JMP ProgramFlow", "[ProgramFlow]") { Init() auto apu = snes.apu; @@ -732,15 +732,15 @@ Test(ProgramFlow, JMP) apu->_internalWrite(0x32, 0b00001111); apu->_internalWrite(0x33, 0b11110000); result = apu->JMP(apu->_getAbsoluteAddr()); - cr_assert_eq(result, 3); - cr_assert_eq(apu->_internalRegisters.pc, 61455); + REQUIRE(result == 3); + REQUIRE(apu->_internalRegisters.pc == 61455); apu->_internalRegisters.pc = 0x32; apu->_internalRegisters.x = 0b000000001; apu->_internalWrite(0b1111000000001111 + 1, 0b00010000); apu->_internalWrite(0b1111000000001111 + 2, 0b11110001); result = apu->JMP(apu->_getAbsoluteByXAddr(), true); - cr_assert_eq(result, 6); - cr_assert_eq(apu->_internalRegisters.pc, 61712); + REQUIRE(result == 6); + REQUIRE(apu->_internalRegisters.pc == 61712); } //////////////////////////////// @@ -749,7 +749,7 @@ Test(ProgramFlow, JMP) // // //////////////////////////////// -Test(DecimalCompensation, DAA) +TEST_CASE("DAA DecimalCompensation", "[DecimalCompensation]") { Init() auto apu = snes.apu; @@ -759,11 +759,11 @@ Test(DecimalCompensation, DAA) apu->_internalRegisters.h = true; apu->_internalRegisters.a = 0x1A; result = apu->DAA(); - cr_assert_eq(result, 3); - cr_assert_eq(apu->_internalRegisters.a, 0x80); + REQUIRE(result == 3); + REQUIRE(apu->_internalRegisters.a == 0x80); } -Test(DecimalCompensation, DAS) +TEST_CASE("DAS DecimalCompensation", "[DecimalCompensation]") { Init() auto apu = snes.apu; @@ -773,8 +773,8 @@ Test(DecimalCompensation, DAS) apu->_internalRegisters.h = false; apu->_internalRegisters.a = 0xFF; result = apu->DAS(); - cr_assert_eq(result, 3); - cr_assert_eq(apu->_internalRegisters.a, 0x99); + REQUIRE(result == 3); + REQUIRE(apu->_internalRegisters.a == 0x99); } /////////////////////////////////// @@ -783,7 +783,7 @@ Test(DecimalCompensation, DAS) // // /////////////////////////////////// -Test(MultiplicationDivision, MUL) +TEST_CASE("MUL MultiplicationDivision", "[MultiplicationDivision]") { Init() auto apu = snes.apu; @@ -792,11 +792,11 @@ Test(MultiplicationDivision, MUL) apu->_internalRegisters.a = 10; apu->_internalRegisters.y = 23; result = apu->MUL(); - cr_assert_eq(result, 9); - cr_assert_eq(apu->_internalRegisters.ya, 230); + REQUIRE(result == 9); + REQUIRE(apu->_internalRegisters.ya == 230); } -Test(MultiplicationDivision, DIV) +TEST_CASE("DIV MultiplicationDivision", "[MultiplicationDivision]") { Init() auto apu = snes.apu; @@ -805,14 +805,14 @@ Test(MultiplicationDivision, DIV) apu->_internalRegisters.ya = 235; apu->_internalRegisters.x = 10; result = apu->DIV(); - cr_assert_eq(result, 12); - cr_assert_eq(apu->_internalRegisters.y, 5); - cr_assert_eq(apu->_internalRegisters.a, 23); + REQUIRE(result == 12); + REQUIRE(apu->_internalRegisters.y == 5); + REQUIRE(apu->_internalRegisters.a == 23); apu->_internalRegisters.ya = 12345; apu->_internalRegisters.x = 2; result = apu->DIV(); - cr_assert_eq(apu->_internalRegisters.y, 147); - cr_assert_eq(apu->_internalRegisters.a, 211); + REQUIRE(apu->_internalRegisters.y == 147); + REQUIRE(apu->_internalRegisters.a == 211); } ////////////////////////////////// @@ -821,7 +821,7 @@ Test(MultiplicationDivision, DIV) // // ////////////////////////////////// -Test(XVIbitArithmetic, INCW) +TEST_CASE("INCW XVIbitArithmetic", "[XVIbitArithmetic]") { Init() auto apu = snes.apu; @@ -831,12 +831,12 @@ Test(XVIbitArithmetic, INCW) apu->_internalWrite(0x55, 0xFF); apu->_internalWrite(0x55 + 1, 0x22); result = apu->INCW(apu->_getDirectAddr()); - cr_assert_eq(result, 6); - cr_assert_eq(apu->_internalRead(0x55), 0x00); - cr_assert_eq(apu->_internalRead(0x55 + 1), 0x23); + REQUIRE(result == 6); + REQUIRE(apu->_internalRead(0x55) == 0x00); + REQUIRE(apu->_internalRead(0x55 + 1) == 0x23); } -Test(XVIbitArithmetic, DECW) +TEST_CASE("DECW XVIbitArithmetic", "[XVIbitArithmetic]") { Init() auto apu = snes.apu; @@ -846,12 +846,12 @@ Test(XVIbitArithmetic, DECW) apu->_internalWrite(0x55, 0x00); apu->_internalWrite(0x55 + 1, 0x23); result = apu->DECW(apu->_getDirectAddr()); - cr_assert_eq(result, 6); - cr_assert_eq(apu->_internalRead(0x55), 0xFF); - cr_assert_eq(apu->_internalRead(0x55 + 1), 0x22); + REQUIRE(result == 6); + REQUIRE(apu->_internalRead(0x55) == 0xFF); + REQUIRE(apu->_internalRead(0x55 + 1) == 0x22); } -Test(XVIbitArithmetic, ADDW) +TEST_CASE("ADDW XVIbitArithmetic", "[XVIbitArithmetic]") { Init() auto apu = snes.apu; @@ -862,14 +862,14 @@ Test(XVIbitArithmetic, ADDW) apu->_internalWrite(0x55, 0x11); apu->_internalWrite(0x55 + 1, 0x22); result = apu->ADDW(apu->_getDirectAddr()); - cr_assert_eq(result, 5); - cr_assert_eq(apu->_internalRegisters.ya, 0x6532); - cr_assert_eq(apu->_internalRegisters.v, false); - cr_assert_eq(apu->_internalRegisters.h, false); - cr_assert_eq(apu->_internalRegisters.c, false); + REQUIRE(result == 5); + REQUIRE(apu->_internalRegisters.ya == 0x6532); + REQUIRE(apu->_internalRegisters.v == false); + REQUIRE(apu->_internalRegisters.h == false); + REQUIRE(apu->_internalRegisters.c == false); } -Test(XVIbitArithmetic, SUBW) +TEST_CASE("SUBW XVIbitArithmetic", "[XVIbitArithmetic]") { Init() auto apu = snes.apu; @@ -880,14 +880,14 @@ Test(XVIbitArithmetic, SUBW) apu->_internalWrite(0x55, 0x11); apu->_internalWrite(0x55 + 1, 0x22); result = apu->SUBW(apu->_getDirectAddr()); - cr_assert_eq(result, 5); - cr_assert_eq(apu->_internalRegisters.ya, 0x2110); - cr_assert_eq(apu->_internalRegisters.v, false); - cr_assert_eq(apu->_internalRegisters.h, true); - cr_assert_eq(apu->_internalRegisters.c, true); + REQUIRE(result == 5); + REQUIRE(apu->_internalRegisters.ya == 0x2110); + REQUIRE(apu->_internalRegisters.v == false); + REQUIRE(apu->_internalRegisters.h == true); + REQUIRE(apu->_internalRegisters.c == true); } -Test(XVIbitArithmetic, CMPW) +TEST_CASE("CMPW XVIbitArithmetic", "[XVIbitArithmetic]") { Init() auto apu = snes.apu; @@ -898,8 +898,8 @@ Test(XVIbitArithmetic, CMPW) apu->_internalWrite(0x55, 0x11); apu->_internalWrite(0x55 + 1, 0x22); result = apu->CMPW(apu->_getDirectAddr()); - cr_assert_eq(result, 4); - cr_assert_eq(apu->_internalRegisters.c, true); + REQUIRE(result == 4); + REQUIRE(apu->_internalRegisters.c == true); } ///////////////////////////////////////// @@ -908,7 +908,7 @@ Test(XVIbitArithmetic, CMPW) // // ///////////////////////////////////////// -Test(XVIbitDataTransmission, MOVW) +TEST_CASE("MOVW XVIbitDataTransmission", "[XVIbitDataTransmission]") { Init() auto apu = snes.apu; @@ -918,15 +918,15 @@ Test(XVIbitDataTransmission, MOVW) apu->_internalRegisters.ya = 0x2211; apu->_internalWrite(apu->_internalRegisters.pc, 0x55); result = apu->MOVW(apu->_getDirectAddr()); - cr_assert_eq(result, 5); - cr_assert_eq(apu->_internalRead(0x55), 0x11); - cr_assert_eq(apu->_internalRead(0x56), 0x22); + REQUIRE(result == 5); + REQUIRE(apu->_internalRead(0x55) == 0x11); + REQUIRE(apu->_internalRead(0x56) == 0x22); apu->_internalRegisters.ya = 0x0000; apu->_internalRegisters.pc = 0; apu->_internalWrite(0x55, 0x33); apu->_internalWrite(0x55 + 1, 0x44); apu->MOVW(apu->_getDirectAddr(), true); - cr_assert_eq(apu->_internalRegisters.ya, 0x4433); + REQUIRE(apu->_internalRegisters.ya == 0x4433); } ////////////////////////////////////// @@ -935,7 +935,7 @@ Test(XVIbitDataTransmission, MOVW) // // ////////////////////////////////////// -Test(VIIIbitShiftRotation, ASL) +TEST_CASE("ASL VIIIbitShiftRotation", "[VIIIbitShiftRotation]") { Init() auto apu = snes.apu; @@ -943,18 +943,18 @@ Test(VIIIbitShiftRotation, ASL) apu->_internalRegisters.a = 0x66; result = apu->ASL(apu->_internalRegisters.a, 2, true); - cr_assert_eq(result, 2); - cr_assert_eq(apu->_internalRegisters.a, 0xCC); - cr_assert_eq(apu->_internalRegisters.c, false); + REQUIRE(result == 2); + REQUIRE(apu->_internalRegisters.a == 0xCC); + REQUIRE(apu->_internalRegisters.c == false); apu->_internalWrite(apu->_internalRegisters.pc, 0x55); apu->_internalWrite(0x55, 0xDD); result = apu->ASL(apu->_getDirectAddr(), 5); - cr_assert_eq(result, 5); - cr_assert_eq(apu->_internalRead(0x55), 0xBA); - cr_assert_eq(apu->_internalRegisters.c, true); + REQUIRE(result == 5); + REQUIRE(apu->_internalRead(0x55) == 0xBA); + REQUIRE(apu->_internalRegisters.c == true); } -Test(VIIIbitShiftRotation, LSR) +TEST_CASE("LSR VIIIbitShiftRotation", "[VIIIbitShiftRotation]") { Init() auto apu = snes.apu; @@ -962,18 +962,18 @@ Test(VIIIbitShiftRotation, LSR) apu->_internalRegisters.a = 0x66; result = apu->LSR(apu->_internalRegisters.a, 2, true); - cr_assert_eq(result, 2); - cr_assert_eq(apu->_internalRegisters.a, 0x33); - cr_assert_eq(apu->_internalRegisters.c, false); + REQUIRE(result == 2); + REQUIRE(apu->_internalRegisters.a == 0x33); + REQUIRE(apu->_internalRegisters.c == false); apu->_internalWrite(apu->_internalRegisters.pc, 0x55); apu->_internalWrite(0x55, 0xDD); result = apu->LSR(apu->_getDirectAddr(), 5); - cr_assert_eq(result , 5); - cr_assert_eq(apu->_internalRead(0x55), 0x6E); - cr_assert_eq(apu->_internalRegisters.c, true); + REQUIRE(result == 5); + REQUIRE(apu->_internalRead(0x55) == 0x6E); + REQUIRE(apu->_internalRegisters.c == true); } -Test(VIIIbitShiftRotation, ROL) +TEST_CASE("ROL VIIIbitShiftRotation", "[VIIIbitShiftRotation]") { Init() auto apu = snes.apu; @@ -981,18 +981,18 @@ Test(VIIIbitShiftRotation, ROL) apu->_internalRegisters.a = 0x66; result = apu->ROL(apu->_internalRegisters.a, 2, true); - cr_assert_eq(result, 2); - cr_assert_eq(apu->_internalRegisters.a, 0xCC); - cr_assert_eq(apu->_internalRegisters.c, false); + REQUIRE(result == 2); + REQUIRE(apu->_internalRegisters.a == 0xCC); + REQUIRE(apu->_internalRegisters.c == false); apu->_internalWrite(apu->_internalRegisters.pc, 0x55); apu->_internalWrite(0x55, 0xDD); result = apu->ROL(apu->_getDirectAddr(), 5); - cr_assert_eq(result, 5); - cr_assert_eq(apu->_internalRead(0x55), 0xBA); - cr_assert_eq(apu->_internalRegisters.c, true); + REQUIRE(result == 5); + REQUIRE(apu->_internalRead(0x55) == 0xBA); + REQUIRE(apu->_internalRegisters.c == true); } -Test(VIIIbitShiftRotation, ROR) +TEST_CASE("ROR VIIIbitShiftRotation", "[VIIIbitShiftRotation]") { Init() auto apu = snes.apu; @@ -1000,18 +1000,18 @@ Test(VIIIbitShiftRotation, ROR) apu->_internalRegisters.a = 0x66; result = apu->ROR(apu->_internalRegisters.a, 2, true); - cr_assert_eq(result, 2); - cr_assert_eq(apu->_internalRegisters.a, 0x33); - cr_assert_eq(apu->_internalRegisters.c, false); + REQUIRE(result == 2); + REQUIRE(apu->_internalRegisters.a == 0x33); + REQUIRE(apu->_internalRegisters.c == false); apu->_internalWrite(apu->_internalRegisters.pc, 0x55); apu->_internalWrite(0x55, 0xDD); result = apu->ROR(apu->_getDirectAddr(), 5); - cr_assert_eq(result , 5); - cr_assert_eq(apu->_internalRead(0x55), 0x6E); - cr_assert_eq(apu->_internalRegisters.c, true); + REQUIRE(result == 5); + REQUIRE(apu->_internalRead(0x55) == 0x6E); + REQUIRE(apu->_internalRegisters.c == true); } -Test(VIIIShiftRotation, XCN) +TEST_CASE("XCN VIIIShiftRotation", "[VIIIShiftRotation]") { Init() auto apu = snes.apu; @@ -1019,8 +1019,8 @@ Test(VIIIShiftRotation, XCN) apu->_internalRegisters.a = 0b10101010; result = apu->XCN(); - cr_assert_eq(result, 5); - cr_assert_eq(apu->_internalRegisters.a, 0xAA); + REQUIRE(result == 5); + REQUIRE(apu->_internalRegisters.a == 0xAA); } /////////////////////////////////////////// @@ -1029,7 +1029,7 @@ Test(VIIIShiftRotation, XCN) // // /////////////////////////////////////////// -Test(VIIIbitIncrementDecrement, INC) +TEST_CASE("INC VIIIbitIncrementDecrement", "[VIIIbitIncrementDecrement]") { Init() auto apu = snes.apu; @@ -1038,11 +1038,11 @@ Test(VIIIbitIncrementDecrement, INC) apu->_internalWrite(apu->_internalRegisters.pc, 0x55); apu->_internalWrite(0x55, 0xDD); result = apu->INC(apu->_getDirectAddr(), 4); - cr_assert_eq(result, 4); - cr_assert_eq(apu->_internalRead(0x55), 0xDE); + REQUIRE(result == 4); + REQUIRE(apu->_internalRead(0x55) == 0xDE); } -Test(VIIIbitIncrementDecrement, INCreg) +TEST_CASE("INCreg VIIIbitIncrementDecrement", "[VIIIbitIncrementDecrement]") { Init() auto apu = snes.apu; @@ -1050,11 +1050,11 @@ Test(VIIIbitIncrementDecrement, INCreg) apu->_internalRegisters.a = 0x76; result = apu->INCreg(apu->_internalRegisters.a); - cr_assert_eq(result, 2); - cr_assert_eq(apu->_internalRegisters.a, 0x77); + REQUIRE(result == 2); + REQUIRE(apu->_internalRegisters.a == 0x77); } -Test(VIIIbitIncrementDecrement, DEC) +TEST_CASE("DEC VIIIbitIncrementDecrement", "[VIIIbitIncrementDecrement]") { Init() auto apu = snes.apu; @@ -1063,11 +1063,11 @@ Test(VIIIbitIncrementDecrement, DEC) apu->_internalWrite(apu->_internalRegisters.pc, 0x55); apu->_internalWrite(0x55, 0xDD); result = apu->DEC(apu->_getDirectAddr(), 4); - cr_assert_eq(result, 4); - cr_assert_eq(apu->_internalRead(0x55), 0xDC); + REQUIRE(result == 4); + REQUIRE(apu->_internalRead(0x55) == 0xDC); } -Test(VIIIbitIncrementDecrement, DECreg) +TEST_CASE("DECreg VIIIbitIncrementDecrement", "[VIIIbitIncrementDecrement]") { Init() auto apu = snes.apu; @@ -1075,8 +1075,8 @@ Test(VIIIbitIncrementDecrement, DECreg) apu->_internalRegisters.a = 0x76; result = apu->DECreg(apu->_internalRegisters.a); - cr_assert_eq(result, 2); - cr_assert_eq(apu->_internalRegisters.a, 0x75); + REQUIRE(result == 2); + REQUIRE(apu->_internalRegisters.a == 0x75); } /////////////////////////////// @@ -1085,7 +1085,7 @@ Test(VIIIbitIncrementDecrement, DECreg) // // /////////////////////////////// -Test(VIIILogical, ANDacc) +TEST_CASE("ANDacc VIIILogical", "[VIIILogical]") { Init() auto apu = snes.apu; @@ -1095,11 +1095,11 @@ Test(VIIILogical, ANDacc) apu->_internalRegisters.a = 24; apu->_internalWrite(4, 23); result = apu->ANDacc(apu->_getIndexXAddr(), 3); - cr_assert_eq(result, 3); - cr_assert_eq(apu->_internalRegisters.a, 16); + REQUIRE(result == 3); + REQUIRE(apu->_internalRegisters.a == 16); } -Test(VIIILogical, AND) +TEST_CASE("AND VIIILogical", "[VIIILogical]") { Init() auto apu = snes.apu; @@ -1110,11 +1110,11 @@ Test(VIIILogical, AND) apu->_internalWrite(4, 12); apu->_internalWrite(7, 44); result = apu->AND(apu->_getIndexXAddr(), apu->_getIndexYAddr(), 5); - cr_assert_eq(result, 5); - cr_assert_eq(apu->_internalRead(4), 12); + REQUIRE(result == 5); + REQUIRE(apu->_internalRead(4) == 12); } -Test(VIIILogical, ORacc) +TEST_CASE("ORacc VIIILogical", "[VIIILogical]") { Init() auto apu = snes.apu; @@ -1124,11 +1124,11 @@ Test(VIIILogical, ORacc) apu->_internalRegisters.a = 24; apu->_internalWrite(4, 23); result = apu->ORacc(apu->_getIndexXAddr(), 3); - cr_assert_eq(result, 3); - cr_assert_eq(apu->_internalRegisters.a, 31); + REQUIRE(result == 3); + REQUIRE(apu->_internalRegisters.a == 31); } -Test(VIIILogical, OR) +TEST_CASE("OR VIIILogical", "[VIIILogical]") { Init() auto apu = snes.apu; @@ -1139,11 +1139,11 @@ Test(VIIILogical, OR) apu->_internalWrite(4, 12); apu->_internalWrite(7, 44); result = apu->OR(apu->_getIndexXAddr(), apu->_getIndexYAddr(), 5); - cr_assert_eq(result, 5); - cr_assert_eq(apu->_internalRead(4), 44); + REQUIRE(result == 5); + REQUIRE(apu->_internalRead(4) == 44); } -Test(VIIILogical, EORacc) +TEST_CASE("EORacc VIIILogical", "[VIIILogical]") { Init() auto apu = snes.apu; @@ -1153,14 +1153,14 @@ Test(VIIILogical, EORacc) apu->_internalRegisters.a = 24; apu->_internalWrite(4, 23); result = apu->EORacc(apu->_getIndexXAddr(), 3); - cr_assert_eq(result, 3); - cr_assert_eq(apu->_internalRegisters.a, 15); + REQUIRE(result == 3); + REQUIRE(apu->_internalRegisters.a == 15); } -Test(VIIILogical, EOR) +TEST_CASE("EOR VIIILogical", "[VIIILogical]") { Init() - auto apu = snes.apu; + auto &apu = snes.apu; int result = 0; apu->_internalRegisters.x = 4; @@ -1168,8 +1168,8 @@ Test(VIIILogical, EOR) apu->_internalWrite(4, 12); apu->_internalWrite(7, 44); result = apu->EOR(apu->_getIndexXAddr(), apu->_getIndexYAddr(), 5); - cr_assert_eq(result, 5); - cr_assert_eq(apu->_internalRead(4), 32); + REQUIRE(result == 5); + REQUIRE(apu->_internalRead(4) == 32); } ////////////////////////////////// @@ -1178,7 +1178,7 @@ Test(VIIILogical, EOR) // // ////////////////////////////////// -Test(VIIIArithmetic, ADC) +TEST_CASE("ADC VIIIArithmetic", "[VIIIArithmetic]") { Init() auto apu = snes.apu; @@ -1190,14 +1190,14 @@ Test(VIIIArithmetic, ADC) apu->_internalWrite(4, 53); apu->_internalWrite(7, 76); result = apu->ADC(apu->_getIndexXAddr(), apu->_getIndexYAddr(), 5); - cr_assert_eq(result, 5); - cr_assert_eq(apu->_internalRead(4), 130); - cr_assert_eq(apu->_internalRegisters.c, false); - cr_assert_eq(apu->_internalRegisters.h, true); - cr_assert_eq(apu->_internalRegisters.v, true); + REQUIRE(result == 5); + REQUIRE(apu->_internalRead(4) == 130); + REQUIRE(apu->_internalRegisters.c == false); + REQUIRE(apu->_internalRegisters.h == true); + REQUIRE(apu->_internalRegisters.v == true); } -Test(VIIIArithmetic, ADCacc) +TEST_CASE("ADCacc VIIIArithmetic", "[VIIIArithmetic]") { Init() auto apu = snes.apu; @@ -1208,14 +1208,14 @@ Test(VIIIArithmetic, ADCacc) apu->_internalRegisters.c = true; apu->_internalWrite(4, 76); result = apu->ADCacc(apu->_getIndexXAddr(), 3); - cr_assert_eq(result, 3); - cr_assert_eq(apu->_internalRegisters.a, 130); - cr_assert_eq(apu->_internalRegisters.c, false); - cr_assert_eq(apu->_internalRegisters.h, true); - cr_assert_eq(apu->_internalRegisters.v, true); + REQUIRE(result == 3); + REQUIRE(apu->_internalRegisters.a == 130); + REQUIRE(apu->_internalRegisters.c == false); + REQUIRE(apu->_internalRegisters.h == true); + REQUIRE(apu->_internalRegisters.v == true); } -Test(VIIIArithmetic, SBC) +TEST_CASE("SBC VIIIArithmetic", "[VIIIArithmetic]") { Init() auto apu = snes.apu; @@ -1227,14 +1227,14 @@ Test(VIIIArithmetic, SBC) apu->_internalWrite(4, 67); apu->_internalWrite(7, 45); result = apu->SBC(apu->_getIndexXAddr(), apu->_getIndexYAddr(), 5); - cr_assert_eq(result, 5); - cr_assert_eq(apu->_internalRead(4), 22); - cr_assert_eq(apu->_internalRegisters.c, true); - cr_assert_eq(apu->_internalRegisters.h, false); - cr_assert_eq(apu->_internalRegisters.v, false); + REQUIRE(result == 5); + REQUIRE(apu->_internalRead(4) == 22); + REQUIRE(apu->_internalRegisters.c == true); + REQUIRE(apu->_internalRegisters.h == false); + REQUIRE(apu->_internalRegisters.v == false); } -Test(VIIIArithmetic, SBCacc) +TEST_CASE("SBCacc VIIIArithmetic", "[VIIIArithmetic]") { Init() auto apu = snes.apu; @@ -1245,14 +1245,14 @@ Test(VIIIArithmetic, SBCacc) apu->_internalRegisters.c = true; apu->_internalWrite(4, 45); result = apu->SBCacc(apu->_getIndexXAddr(), 3); - cr_assert_eq(result, 3); - cr_assert_eq(apu->_internalRegisters.a, 22); - cr_assert_eq(apu->_internalRegisters.c, true); - cr_assert_eq(apu->_internalRegisters.h, false); - cr_assert_eq(apu->_internalRegisters.v, false); + REQUIRE(result == 3); + REQUIRE(apu->_internalRegisters.a == 22); + REQUIRE(apu->_internalRegisters.c == true); + REQUIRE(apu->_internalRegisters.h == false); + REQUIRE(apu->_internalRegisters.v == false); } -Test(VIIIArithmetic, CMP) +TEST_CASE("CMP VIIIArithmetic", "[VIIIArithmetic]") { Init() auto apu = snes.apu; @@ -1263,11 +1263,11 @@ Test(VIIIArithmetic, CMP) apu->_internalWrite(4, 67); apu->_internalWrite(7, 45); result = apu->CMP(apu->_getIndexXAddr(), apu->_getIndexYAddr(), 5); - cr_assert_eq(result, 5); - cr_assert_eq(apu->_internalRegisters.c, true); + REQUIRE(result == 5); + REQUIRE(apu->_internalRegisters.c == true); } -Test(VIIIArithmetic, CMPacc) +TEST_CASE("CMPacc VIIIArithmetic", "[VIIIArithmetic]") { Init() auto apu = snes.apu; @@ -1277,8 +1277,8 @@ Test(VIIIArithmetic, CMPacc) apu->_internalRegisters.a = 67; apu->_internalWrite(4, 45); result = apu->CMPreg(apu->_internalRegisters.a, apu->_getIndexXAddr(), 3); - cr_assert_eq(result, 3); - cr_assert_eq(apu->_internalRegisters.c, true); + REQUIRE(result == 3); + REQUIRE(apu->_internalRegisters.c == true); } ///////////////////////////////////////// @@ -1287,7 +1287,7 @@ Test(VIIIArithmetic, CMPacc) // // ///////////////////////////////////////// -Test(VIIIDataTransmission, MovRegToReg) +TEST_CASE("MovRegToReg VIIIDataTransmission", "[VIIIDataTransmission]") { Init() auto apu = snes.apu; @@ -1296,11 +1296,11 @@ Test(VIIIDataTransmission, MovRegToReg) apu->_internalRegisters.a = 23; apu->_internalRegisters.x = 45; result = apu->MOV(apu->_internalRegisters.x, apu->_internalRegisters.a); - cr_assert_eq(result, 2); - cr_assert_eq(apu->_internalRegisters.a, 45); + REQUIRE(result == 2); + REQUIRE(apu->_internalRegisters.a == 45); } -Test(VIIIDataTransmission, MovMemToMem) +TEST_CASE("MovMemToMem VIIIDataTransmission", "[VIIIDataTransmission]") { Init() auto apu = snes.apu; @@ -1312,11 +1312,11 @@ Test(VIIIDataTransmission, MovMemToMem) apu->_internalWrite(0x56, 99); apu->_internalWrite(0x33, 66); result = apu->MOV(apu->_getDirectAddr(), apu->_getImmediateData()); - cr_assert_eq(result, 5); - cr_assert_eq(apu->_internalRead(0x33), 0x56); + REQUIRE(result == 5); + REQUIRE(apu->_internalRead(0x33) == 0x56); } -Test(VIIIDataTransmission, MovRegToMem) +TEST_CASE("MovRegToMem VIIIDataTransmission", "[VIIIDataTransmission]") { Init() auto apu = snes.apu; @@ -1326,12 +1326,12 @@ Test(VIIIDataTransmission, MovRegToMem) apu->_internalRegisters.a = 0x44; apu->_internalWrite(0x23, 0x56); result = apu->MOV(apu->_internalRegisters.a, apu->_getIndexXAddr(), 4, true); - cr_assert_eq(result, 4); - cr_assert_eq(apu->_internalRead(0x23), 0x44); - cr_assert_eq(apu->_internalRegisters.x, 0x24); + REQUIRE(result == 4); + REQUIRE(apu->_internalRead(0x23) == 0x44); + REQUIRE(apu->_internalRegisters.x == 0x24); } -Test(VIIIDataTransmission, MovMemToReg) +TEST_CASE("MovMemToReg VIIIDataTransmission", "[VIIIDataTransmission]") { Init() auto apu = snes.apu; @@ -1340,7 +1340,7 @@ Test(VIIIDataTransmission, MovMemToReg) apu->_internalRegisters.x = 0x23; apu->_internalRegisters.a = 0x44; result = apu->MOV(apu->_getIndexXAddr(), apu->_internalRegisters.a, 4, true); - cr_assert_eq(result, 4); - cr_assert_eq(apu->_internalRegisters.x, 0x24); - cr_assert_eq(apu->_internalRegisters.a, 0x23); + REQUIRE(result == 4); + REQUIRE(apu->_internalRegisters.x == 0x24); + REQUIRE(apu->_internalRegisters.a == 0x23); } \ No newline at end of file diff --git a/tests/APU/testOperand.cpp b/tests/APU/testOperand.cpp index b1abba3..012b948 100644 --- a/tests/APU/testOperand.cpp +++ b/tests/APU/testOperand.cpp @@ -2,7 +2,7 @@ // Created by Melefo on 26/02/2020. // -#include +#include #include "../tests.hpp" #include "../../sources/SNES.hpp" #include "../../sources/APU/APU.hpp" @@ -11,17 +11,17 @@ using namespace ComSquare; -Test(apu_get, immediate) +TEST_CASE("immediate apu_get", "[apu_get]") { Init() auto apu = snes.apu; apu->_internalRegisters.pc = 0x32; apu->_internalWrite(0x32, 0x40); - cr_assert_eq(apu->_getImmediateData(), 0x40); + REQUIRE(apu->_getImmediateData() == 0x40); } -Test(apu_get, direct) +TEST_CASE("direct apu_get", "[apu_get]") { Init() auto apu = snes.apu; @@ -29,30 +29,30 @@ Test(apu_get, direct) apu->_internalRegisters.pc = 0x32; apu->_internalRegisters.p = true; apu->_internalWrite(0x32, 0x40); - cr_assert_eq(apu->_getDirectAddr(), 0x140); + REQUIRE(apu->_getDirectAddr() == 0x140); } -Test(apu_get, X) +TEST_CASE("X apu_get", "[apu_get]") { Init() auto apu = snes.apu; apu->_internalRegisters.x = 0x32; apu->_internalRegisters.p = true; - cr_assert_eq(apu->_getIndexXAddr(), 0x132); + REQUIRE(apu->_getIndexXAddr() == 0x132); } -Test(apu_get, Y) +TEST_CASE("Y apu_get", "[apu_get]") { Init() auto apu = snes.apu; apu->_internalRegisters.y = 0x32; apu->_internalRegisters.p = true; - cr_assert_eq(apu->_getIndexYAddr(), 0x132); + REQUIRE(apu->_getIndexYAddr() == 0x132); } -Test(apu_get, directbyX) +TEST_CASE("directbyX apu_get", "[apu_get]") { Init() auto apu = snes.apu; @@ -60,10 +60,10 @@ Test(apu_get, directbyX) apu->_internalRegisters.pc = 0x32; apu->_internalRegisters.x = 0x03; apu->_internalWrite(0x32, 0x40); - cr_assert_eq(apu->_getDirectAddrByX(), 0x43); + REQUIRE(apu->_getDirectAddrByX() == 0x43); } -Test(apu_get, directbyY) +TEST_CASE("directbyY apu_get", "[apu_get]") { Init() auto apu = snes.apu; @@ -71,10 +71,10 @@ Test(apu_get, directbyY) apu->_internalRegisters.pc = 0x32; apu->_internalRegisters.y = 0x05; apu->_internalWrite(0x32, 0x40); - cr_assert_eq(apu->_getDirectAddrByY(), 0x45); + REQUIRE(apu->_getDirectAddrByY() == 0x45); } -Test(apu_get, absolute) +TEST_CASE("absolute apu_get", "[apu_get]") { Init() auto apu = snes.apu; @@ -82,10 +82,10 @@ Test(apu_get, absolute) apu->_internalRegisters.pc = 0x32; apu->_internalWrite(0x32, 0b00001111); apu->_internalWrite(0x33, 0b11110000); - cr_assert_eq(apu->_getAbsoluteAddr(), 61455); + REQUIRE(apu->_getAbsoluteAddr() == 61455); } -Test(apu_get, absolutebyx) +TEST_CASE("absolutebyx apu_get", "[apu_get]") { Init() auto apu = snes.apu; @@ -95,10 +95,10 @@ Test(apu_get, absolutebyx) apu->_internalWrite(0x32, 0b00001111); apu->_internalWrite(0x33, 0b11110000); apu->_internalWrite(0b1111000000001111 + 10, 255); - cr_assert_eq(apu->_getAbsoluteByXAddr(), 255); + REQUIRE(apu->_getAbsoluteByXAddr() == 255); } -Test(apu_get, absoluteaddrbyx) +TEST_CASE("absoluteaddrbyx apu_get", "[apu_get]") { Init() auto apu = snes.apu; @@ -107,10 +107,10 @@ Test(apu_get, absoluteaddrbyx) apu->_internalRegisters.x = 10; apu->_internalWrite(0x32, 0b00001111); apu->_internalWrite(0x33, 0b11110000); - cr_assert_eq(apu->_getAbsoluteAddrByX(), 61465); + REQUIRE(apu->_getAbsoluteAddrByX() == 61465); } -Test(apu_get, absoluteaddrbyy) +TEST_CASE("absoluteaddrbyy apu_get", "[apu_get]") { Init() auto apu = snes.apu; @@ -119,10 +119,10 @@ Test(apu_get, absoluteaddrbyy) apu->_internalRegisters.y = 10; apu->_internalWrite(0x32, 0b00001111); apu->_internalWrite(0x33, 0b11110000); - cr_assert_eq(apu->_getAbsoluteAddrByY(), 61465); + REQUIRE(apu->_getAbsoluteAddrByY() == 61465); } -Test(apu_get, absolutebit) +TEST_CASE("absolutebit apu_get", "[apu_get]") { Init() auto apu = snes.apu; @@ -132,11 +132,11 @@ Test(apu_get, absolutebit) apu->_internalWrite(0x32, 0b00001111); apu->_internalWrite(0x33, 0b11110000); result = apu->_getAbsoluteBit(); - cr_assert_eq(result.first, 4111); - cr_assert_eq(result.second, 7); + REQUIRE(result.first == 4111); + REQUIRE(result.second == 7); } -Test(apu_get, absolutebyxdirect) +TEST_CASE("absolutebyxdirect apu_get", "[apu_get]") { Init() auto apu = snes.apu; @@ -147,10 +147,10 @@ Test(apu_get, absolutebyxdirect) apu->_internalWrite(0x32, 0x42); apu->_internalWrite(0x152, 0b00001101); apu->_internalWrite(0x253, 0b01101011); - cr_assert_eq(apu->_getAbsoluteDirectByXAddr(), 0b0110101100001101); + REQUIRE(apu->_getAbsoluteDirectByXAddr() == 0b0110101100001101); } -Test(apu_get, absolutedirectbyy) +TEST_CASE("absolutedirectbyy apu_get", "[apu_get]") { Init() auto apu = snes.apu; @@ -161,5 +161,5 @@ Test(apu_get, absolutedirectbyy) apu->_internalWrite(0x32, 0x42); apu->_internalWrite(0x142, 0b00001101); apu->_internalWrite(0x243, 0b01101011); - cr_assert_eq(apu->_getAbsoluteDirectAddrByY(), 0b0110101100011101); + REQUIRE(apu->_getAbsoluteDirectAddrByY() == 0b0110101100011101); } \ No newline at end of file diff --git a/tests/CPU/Math/testADC.cpp b/tests/CPU/Math/testADC.cpp index 3d4f193..f86debb 100644 --- a/tests/CPU/Math/testADC.cpp +++ b/tests/CPU/Math/testADC.cpp @@ -2,111 +2,111 @@ // Created by anonymus-raccoon on 2/11/20. // -#include +#include #include #include "../../tests.hpp" #include "../../../sources/SNES.hpp" using namespace ComSquare; -Test(ADC, addingOne) +TEST_CASE("addingOne ADC", "[ADC]") { Init() snes.cpu->_isEmulationMode = false; snes.cpu->_registers.a = 0; snes.wram->_data[0] = 0x1; snes.cpu->ADC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 1, "The accumulator's value should be 0x1 but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.v, false, "The overflow flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.a == 1); + REQUIRE(snes.cpu->_registers.p.c == false); + REQUIRE(snes.cpu->_registers.p.v == false); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(ADC, addingOneEmulation) +TEST_CASE("addingOneEmulation ADC", "[ADC]") { Init() snes.cpu->_isEmulationMode = true; snes.cpu->_registers.a = 0; snes.wram->_data[0] = 0x1; snes.cpu->ADC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 1, "The accumulator's value should be 0x1 but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.v, false, "The overflow flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.a == 1); + REQUIRE(snes.cpu->_registers.p.c == false); + REQUIRE(snes.cpu->_registers.p.v == false); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(ADC, overflow) +TEST_CASE("overflow ADC", "[ADC]") { Init() snes.cpu->_isEmulationMode = false; snes.cpu->_registers.a = 0xFFFF; snes.wram->_data[0] = 0x1; snes.cpu->ADC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0, "The accumulator's value should be 0x0 but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.v, false, "The overflow flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flags should be set."); + REQUIRE(snes.cpu->_registers.a == 0); + REQUIRE(snes.cpu->_registers.p.c == true); + REQUIRE(snes.cpu->_registers.p.v == false); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == true); } -Test(ADC, overflowEmulation) +TEST_CASE("overflowEmulation ADC", "[ADC]") { Init() snes.cpu->_isEmulationMode = true; snes.cpu->_registers.a = 0xFF; snes.wram->_data[0] = 0x1; snes.cpu->ADC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0, "The accumulator's value should be 0x0 but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.v, false, "The overflow flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flags should be set."); + REQUIRE(snes.cpu->_registers.a == 0); + REQUIRE(snes.cpu->_registers.p.c == true); + REQUIRE(snes.cpu->_registers.p.v == false); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == true); } -Test(ADC, signedOverflow) +TEST_CASE("signedOverflow ADC", "[ADC]") { Init() snes.cpu->_registers.p.m = false; snes.cpu->_registers.a = 0x7FFF; snes.wram->_data[0] = 0x1; snes.cpu->ADC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0x8000, "The accumulator's value should be 0x8000 but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.v, true, "The overflow flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.a == 0x8000); + REQUIRE(snes.cpu->_registers.p.c == false); + REQUIRE(snes.cpu->_registers.p.v == true); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(ADC, signedOverflowEmulated) +TEST_CASE("signedOverflowEmulated ADC", "[ADC]") { Init() snes.cpu->_registers.p.m = true; snes.cpu->_registers.a = 0x007F; snes.wram->_data[0] = 0x1; snes.cpu->ADC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0x0080, "The accumulator's value should be 0x0080 but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.v, true, "The overflow flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.a == 0x0080); + REQUIRE(snes.cpu->_registers.p.c == false); + REQUIRE(snes.cpu->_registers.p.v == true); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(ADC, negative) +TEST_CASE("negative ADC", "[ADC]") { Init() snes.cpu->_registers.p.m = false; snes.cpu->_registers.a = 0x8FFF; snes.wram->_data[0] = 0x1; snes.cpu->ADC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0x9000, "The accumulator's value should be 0x9000 but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.v, false, "The overflow flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.a == 0x9000); + REQUIRE(snes.cpu->_registers.p.c == false); + REQUIRE(snes.cpu->_registers.p.v == false); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(ADC, memoryTwoBytes) +TEST_CASE("memoryTwoBytes ADC", "[ADC]") { Init() snes.cpu->_isEmulationMode = false; @@ -115,9 +115,9 @@ Test(ADC, memoryTwoBytes) snes.wram->_data[0] = 0x01; snes.wram->_data[1] = 0x04; snes.cpu->ADC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0x0410, "The accumulator's value should be 0x0410 but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.v, false, "The overflow flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.a == 0x0410); + REQUIRE(snes.cpu->_registers.p.c == false); + REQUIRE(snes.cpu->_registers.p.v == false); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == false); } \ No newline at end of file diff --git a/tests/CPU/Math/testCMP.cpp b/tests/CPU/Math/testCMP.cpp index 47968d4..1309486 100644 --- a/tests/CPU/Math/testCMP.cpp +++ b/tests/CPU/Math/testCMP.cpp @@ -2,37 +2,37 @@ // Created by anonymus-raccoon on 4/6/20. // -#include +#include #include #include "../../tests.hpp" #include "../../../sources/SNES.hpp" using namespace ComSquare; -Test(CMP, underflow) +TEST_CASE("underflow CMP", "[CMP]") { Init() snes.cpu->_registers.p.m = true; snes.cpu->_registers.a = 0; snes.wram->_data[0] = 0x1; snes.cpu->CMP(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.p.c == false); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(CMP, zero) +TEST_CASE("zero CMP", "[CMP]") { Init() snes.cpu->_registers.p.m = true; snes.cpu->_registers.a = 0x5; snes.wram->_data[0] = 0x5; snes.cpu->CMP(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flags should be set."); + REQUIRE(snes.cpu->_registers.p.c == true); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == true); } -Test(CMP, nativeModeZero) +TEST_CASE("nativeModeZero CMP", "[CMP]") { Init() snes.cpu->_registers.p.m = false; @@ -40,12 +40,12 @@ Test(CMP, nativeModeZero) snes.wram->_data[0] = 0x00; snes.wram->_data[1] = 0x50; snes.cpu->CMP(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flags should be set."); + REQUIRE(snes.cpu->_registers.p.c == true); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == true); } -Test(CMP, nativeModeNothing) +TEST_CASE("nativeModeNothing CMP", "[CMP]") { Init() snes.cpu->_registers.p.m = false; @@ -53,12 +53,12 @@ Test(CMP, nativeModeNothing) snes.wram->_data[0] = 0x00; snes.wram->_data[1] = 0x50; snes.cpu->CMP(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.p.c == true); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(CMP, negative) +TEST_CASE("negative CMP", "[CMP]") { Init() snes.cpu->_registers.p.m = false; @@ -66,8 +66,8 @@ Test(CMP, negative) snes.wram->_data[0] = 0x00; snes.wram->_data[1] = 0x10; snes.cpu->CMP(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.p.c == true); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } diff --git a/tests/CPU/Math/testOthersMath.cpp b/tests/CPU/Math/testOthersMath.cpp index a8a6093..7507ac5 100644 --- a/tests/CPU/Math/testOthersMath.cpp +++ b/tests/CPU/Math/testOthersMath.cpp @@ -2,342 +2,342 @@ // Created by anonymus-raccoon on 4/3/20. // -#include +#include #include #include "../../tests.hpp" #include "../../../sources/SNES.hpp" using namespace ComSquare; -Test(DEX, simple) +TEST_CASE("simple DEX", "[DEX]") { Init() snes.cpu->_registers.p.x_b = true; snes.cpu->_registers.x = 0x57; snes.cpu->DEX(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.x, 0x56, "The x index value should be 0x56 but it was 0x%x.", snes.cpu->_registers.x); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.x == 0x56); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(DEX, overflowEmul) +TEST_CASE("overflowEmul DEX", "[DEX]") { Init() snes.cpu->_registers.p.x_b = true; snes.cpu->_registers.x = 0; snes.cpu->DEX(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.x, 0xFF, "The x index value should be 0xFF but it was 0x%x.", snes.cpu->_registers.x); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.x == 0xFF); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(DEX, fakeOverflowNonEmul) +TEST_CASE("fakeOverflowNonEmul DEX", "[DEX]") { Init() snes.cpu->_registers.p.x_b = false; snes.cpu->_registers.x = 0xFF00; snes.cpu->DEX(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.x, 0xFEFF, "The x index value should be 0xFEFF but it was 0x%x.", snes.cpu->_registers.x); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.x == 0xFEFF); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(DEX, nonNegative) +TEST_CASE("nonNegative DEX", "[DEX]") { Init() snes.cpu->_registers.p.x_b = true; snes.cpu->_registers.x = 0x80; snes.cpu->DEX(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.x, 0x7F, "The x index value should be 0x7F but it was 0x%x.", snes.cpu->_registers.x); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.x == 0x7F); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(DEX, zero) +TEST_CASE("zero DEX", "[DEX]") { Init() snes.cpu->_registers.p.x_b = true; snes.cpu->_registers.x = 1; snes.cpu->DEX(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.x, 0, "The x index value should be 0 but it was 0x%x.", snes.cpu->_registers.x); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flags should be set."); + REQUIRE(snes.cpu->_registers.x == 0); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == true); } -Test(DEY, simple) +TEST_CASE("simple DEY", "[DEY]") { Init() snes.cpu->_registers.p.x_b = true; snes.cpu->_registers.y = 0x57; snes.cpu->DEY(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.y, 0x56, "The x index value should be 0x56 but it was 0x%x.", snes.cpu->_registers.y); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.y == 0x56); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(DEY, overflowEmul) +TEST_CASE("overflowEmul DEY", "[DEY]") { Init() snes.cpu->_registers.p.x_b = true; snes.cpu->_registers.y = 0; snes.cpu->DEY(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.y, 0xFF, "The x index value should be 0xFF but it was 0x%x.", snes.cpu->_registers.y); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.y == 0xFF); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(DEY, fakeOverflowNonEmul) +TEST_CASE("fakeOverflowNonEmul DEY", "[DEY]") { Init() snes.cpu->_registers.p.x_b = false; snes.cpu->_registers.y = 0xFF00; snes.cpu->DEY(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.y, 0xFEFF, "The x index value should be 0xFEFF but it was 0x%x.", snes.cpu->_registers.y); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.y == 0xFEFF); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(DEY, nonNegative) +TEST_CASE("nonNegative DEY", "[DEY]") { Init() snes.cpu->_registers.p.x_b = true; snes.cpu->_registers.y = 0x80; snes.cpu->DEY(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.y, 0x7F, "The x index value should be 0x7F but it was 0x%x.", snes.cpu->_registers.y); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.y == 0x7F); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(DEY, zero) +TEST_CASE("zero DEY", "[DEY]") { Init() snes.cpu->_registers.p.x_b = true; snes.cpu->_registers.y = 1; snes.cpu->DEY(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.y, 0, "The x index value should be 0 but it was 0x%x.", snes.cpu->_registers.y); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flags should be set."); + REQUIRE(snes.cpu->_registers.y == 0); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == true); } -Test(ORA, simple) +TEST_CASE("simple ORA", "[ORA]") { Init() snes.cpu->_registers.p.m = true; snes.cpu->_registers.a = 0x80; snes.wram->_data[0] = 0x0F; snes.cpu->ORA(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0x8F, "The accumulator's value should be 0x8F but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.a == 0x8F); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(ORA, simple2) +TEST_CASE("simple2 ORA", "[ORA]") { Init() snes.cpu->_registers.p.m = true; snes.cpu->_registers.a = 0x80; snes.wram->_data[0] = 0xF0; snes.cpu->ORA(0x00, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0xF0, "The accumulator's value should be 0xF0 but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.a == 0xF0); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(ORA, zero) +TEST_CASE("zero ORA", "[ORA]") { Init() snes.cpu->_registers.p.m = true; snes.cpu->_registers.a = 0x00; snes.wram->_data[0] = 0x00; snes.cpu->ORA(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0x00, "The accumulator's value should be 0x00 but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flags should be set."); + REQUIRE(snes.cpu->_registers.a == 0x00); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == true); } -Test(INC, simple) +TEST_CASE("simple INC", "[INC]") { Init() snes.cpu->_registers.p.m = true; snes.wram->_data[0] = 0x56; snes.cpu->INC(0x0, ComSquare::CPU::AddressingMode::Absolute); - cr_assert_eq(snes.wram->_data[0], 0x57, "The incremented value should be 0x57 but it was 0x%x.", snes.wram->_data[0]); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.wram->_data[0] == 0x57); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(INC, negative) +TEST_CASE("negative INC", "[INC]") { Init() snes.cpu->_registers.p.m = true; snes.wram->_data[0] = 0x7F; snes.cpu->INC(0x0, ComSquare::CPU::AddressingMode::Absolute); - cr_assert_eq(snes.wram->_data[0], 0x80, "The incremented value should be 0x80 but it was 0x%x.", snes.wram->_data[0]); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.wram->_data[0] == 0x80); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(INC, accumulator) +TEST_CASE("accumulator INC", "[INC]") { Init() snes.cpu->_registers.p.m = true; snes.cpu->_registers.a = 0x56; snes.cpu->INC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0x57, "The incremented value should be 0x57 but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.a == 0x57); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(INC, negativeAccumulator) +TEST_CASE("negativeAccumulator INC", "[INC]") { Init() snes.cpu->_registers.p.m = true; snes.cpu->_registers.a = 0x7F; snes.cpu->INC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0x80, "The incremented value should be 0x80 but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.a == 0x80); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(INC, nativeAccumulator) +TEST_CASE("nativeAccumulator INC", "[INC]") { Init() snes.cpu->_registers.p.m = false; snes.cpu->_registers.a = 0x5600; snes.cpu->INC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0x5601, "The incremented value should be 0x5601 but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.a == 0x5601); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(INC, negativeNativeAccumulator) +TEST_CASE("negativeNativeAccumulator INC", "[INC]") { Init() snes.cpu->_registers.p.m = false; snes.cpu->_registers.a = 0x8FFF; snes.cpu->INC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0x9000, "The incremented value should be 0x9000 but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.a == 0x9000); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(DEC, simple) +TEST_CASE("simple DEC", "[DEC]") { Init() snes.cpu->_registers.p.m = true; snes.wram->_data[0] = 0x58; snes.cpu->DEC(0x0, ComSquare::CPU::AddressingMode::Absolute); - cr_assert_eq(snes.wram->_data[0], 0x57, "The incremented value should be 0x57 but it was 0x%x.", snes.wram->_data[0]); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.wram->_data[0] == 0x57); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(DEC, negative) +TEST_CASE("negative DEC", "[DEC]") { Init() snes.cpu->_registers.p.m = true; snes.wram->_data[0] = 0x81; snes.cpu->DEC(0x0, ComSquare::CPU::AddressingMode::Absolute); - cr_assert_eq(snes.wram->_data[0], 0x80, "The incremented value should be 0x80 but it was 0x%x.", snes.wram->_data[0]); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.wram->_data[0] == 0x80); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(DEC, accumulator) +TEST_CASE("accumulator DEC", "[DEC]") { Init() snes.cpu->_registers.p.m = true; snes.cpu->_registers.a = 0x58; snes.cpu->DEC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0x57, "The incremented value should be 0x57 but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.a == 0x57); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(DEC, negativeAccumulator) +TEST_CASE("negativeAccumulator DEC", "[DEC]") { Init() snes.cpu->_registers.p.m = true; snes.cpu->_registers.a = 0x81; snes.cpu->DEC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0x80, "The incremented value should be 0x80 but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.a == 0x80); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(DEC, nativeAccumulator) +TEST_CASE("nativeAccumulator DEC", "[DEC]") { Init() snes.cpu->_registers.p.m = false; snes.cpu->_registers.a = 0x5602; snes.cpu->DEC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0x5601, "The incremented value should be 0x5601 but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.a == 0x5601); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(DEC, negativeNativeAccumulator) +TEST_CASE("negativeNativeAccumulator DEC", "[DEC]") { Init() snes.cpu->_registers.p.m = false; snes.cpu->_registers.a = 0x9001; snes.cpu->DEC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0x9000, "The incremented value should be 0x9000 but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.a == 0x9000); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(EOR, simple) +TEST_CASE("simple EOR", "[EOR]") { Init() snes.cpu->_registers.p.m = true; snes.cpu->_registers.a = 0x80; snes.wram->_data[0] = 0x0F; snes.cpu->EOR(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0x8F, "The accumulator's value should be 0x8F but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.a == 0x8F); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(EOR, simple2) +TEST_CASE("simple2 EOR", "[EOR]") { Init() snes.cpu->_registers.p.m = true; snes.cpu->_registers.a = 0x80; snes.wram->_data[0] = 0xF0; snes.cpu->EOR(0x00, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0x70, "The accumulator's value should be 0x70 but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.a == 0x70); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(EOR, zero) +TEST_CASE("zero EOR", "[EOR]") { Init() snes.cpu->_registers.p.m = true; snes.cpu->_registers.a = 0x00; snes.wram->_data[0] = 0x00; snes.cpu->EOR(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0x00, "The accumulator's value should be 0x00 but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flags should be set."); + REQUIRE(snes.cpu->_registers.a == 0x00); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == true); } -Test(XBA, zero) +TEST_CASE("zero XBA", "[XBA]") { Init() snes.cpu->_registers.a = 0x0001; snes.cpu->XBA(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0x0100, "The accumulator's value should be 0x0100 but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flags should be set."); + REQUIRE(snes.cpu->_registers.a == 0x0100); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == true); } -Test(XBA, negative) +TEST_CASE("negative XBA", "[XBA]") { Init() snes.cpu->_registers.a = 0x8001; snes.cpu->XBA(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0x0180, "The accumulator's value should be 0x0180 but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should be not set."); + REQUIRE(snes.cpu->_registers.a == 0x0180); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } diff --git a/tests/CPU/Math/testSBC.cpp b/tests/CPU/Math/testSBC.cpp index e784481..3eebb67 100644 --- a/tests/CPU/Math/testSBC.cpp +++ b/tests/CPU/Math/testSBC.cpp @@ -2,13 +2,13 @@ // Created by anonymus-raccoon on 27/02/20. // -#include +#include #include #include "../../tests.hpp" #include "../../../sources/SNES.hpp" using namespace ComSquare; -Test(SBC, removingOne) +TEST_CASE("removingOne SBC", "[SBC]") { Init() snes.cpu->_isEmulationMode = false; @@ -16,14 +16,14 @@ Test(SBC, removingOne) snes.cpu->_registers.a = 0x1; snes.wram->_data[0] = 0x1; snes.cpu->SBC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0, "The accumulator's value should be 0x0 but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.v, false, "The overflow flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flags should be set."); + REQUIRE(snes.cpu->_registers.a == 0); + REQUIRE(snes.cpu->_registers.p.c == true); + REQUIRE(snes.cpu->_registers.p.v == false); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == true); } -Test(SBC, legitOverflowWithCarry) +TEST_CASE("legitOverflowWithCarry SBC", "[SBC]") { Init() snes.cpu->_isEmulationMode = false; @@ -33,14 +33,14 @@ Test(SBC, legitOverflowWithCarry) snes.wram->_data[0] = 0x03; snes.wram->_data[1] = 0x20; snes.cpu->SBC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0xDFFE, "The accumulator's value should be 0xDFFE but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.v, false, "The overflow flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.a == 0xDFFE); + REQUIRE(snes.cpu->_registers.p.c == false); + REQUIRE(snes.cpu->_registers.p.v == false); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(SBC, overflowWithCarry) +TEST_CASE("overflowWithCarry SBC", "[SBC]") { Init() snes.cpu->_isEmulationMode = false; @@ -50,14 +50,14 @@ Test(SBC, overflowWithCarry) snes.wram->_data[0] = 0x03; snes.wram->_data[1] = 0x20; snes.cpu->SBC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0xDFFE, "The accumulator's value should be 0xDFFE but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.v, false, "The overflow flags should be not set."); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should not be set."); + REQUIRE(snes.cpu->_registers.a == 0xDFFE); + REQUIRE(snes.cpu->_registers.p.c == false); + REQUIRE(snes.cpu->_registers.p.v == false); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(SBC, overflowEmulation) +TEST_CASE("overflowEmulation SBC", "[SBC]") { Init() snes.cpu->_isEmulationMode = true; @@ -66,15 +66,15 @@ Test(SBC, overflowEmulation) snes.cpu->_registers.p.c = false; snes.wram->_data[0] = 0x02; snes.cpu->SBC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0xFE, "The accumulator's value should be 0xFE but it was 0x%x.", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.v, false, "The overflow flags should not be set."); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flags should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should be not set."); + REQUIRE(snes.cpu->_registers.a == 0xFE); + REQUIRE(snes.cpu->_registers.p.c == false); + REQUIRE(snes.cpu->_registers.p.v == false); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -//Test(SBC, decimal) +//TEST_CASE("decimal SBC", "[SBC]") //{ // Init() // snes.cpu->_isEmulationMode = true; @@ -84,9 +84,9 @@ Test(SBC, overflowEmulation) // snes.wram->_data[0] = 0x03; // snes.wram->_data[1] = 0x20; // snes.cpu->SBC(0x0, ComSquare::CPU::AddressingMode::Implied); -// cr_assert_eq(snes.cpu->_registers.a, 0x7998, "The accumulator's value should be 0x7998 but it was 0x%x.", snes.cpu->_registers.a); -// cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flags should not be set."); -// cr_assert_eq(snes.cpu->_registers.p.v, false, "The overflow flags should not be set."); -// cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flags should not be set."); -// cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flags should be not set."); +// REQUIRE(snes.cpu->_registers.a == 0x7998); +// REQUIRE(snes.cpu->_registers.p.c == false); +// REQUIRE(snes.cpu->_registers.p.v == false); +// REQUIRE(snes.cpu->_registers.p.n == false); +// REQUIRE(snes.cpu->_registers.p.z == false); //} diff --git a/tests/CPU/testAddressingMode.cpp b/tests/CPU/testAddressingMode.cpp index 1fd8371..ff7972f 100644 --- a/tests/CPU/testAddressingMode.cpp +++ b/tests/CPU/testAddressingMode.cpp @@ -2,71 +2,69 @@ // Created by anonymus-raccoon on 2/10/20. // -#include -#include -#include +#include #include "../tests.hpp" -#include "../../sources/SNES.hpp" +#include "SNES.hpp" using namespace ComSquare; -Test(AddrModeInit, LegitBus) +TEST_CASE("LegitBus AddrModeInit", "[AddrModeInit]") { Init() - cr_assert_eq(snes.bus.get(), snes.cpu->_bus.get(), "Warning, the CPU's bus is not the same the SNES's bus. Next tests of the CPU may fail."); + REQUIRE(snes.bus.get() == snes.cpu->_bus.get()); } -Test(AddrMode, Immediate) +TEST_CASE("Immediate AddrMode", "[AddrMode]") { Init() snes.cpu->_registers.pac = 0x000015; snes.cpu->_isEmulationMode = true; snes.cpu->_registers.p.m = false; - cr_assert_eq(snes.cpu->_getImmediateAddrForA(), 0x000015, "Got %x, Expected 0x000015"); - cr_assert_eq(snes.cpu->_registers.pac, 0x000017); + REQUIRE(snes.cpu->_getImmediateAddrForA() == 0x000015); + REQUIRE(snes.cpu->_registers.pac == 0x000017); } -Test(AddrMode, ImmediateMemoryFlag) +TEST_CASE("ImmediateMemoryFlag AddrMode", "[AddrMode]") { Init() snes.cpu->_isEmulationMode = true; snes.cpu->_registers.pac = 0x000015; snes.cpu->_registers.p.m = false; - cr_assert_eq(snes.cpu->_getImmediateAddrForA(), 0x000015, "Got %x, Expected 0x000015"); - cr_assert_eq(snes.cpu->_registers.pac, 0x000017); + REQUIRE(snes.cpu->_getImmediateAddrForA() == 0x000015); + REQUIRE(snes.cpu->_registers.pac == 0x000017); } -Test(AddrMode, ImmediateBankChange) +TEST_CASE("ImmediateBankChange AddrMode", "[AddrMode]") { Init() snes.cpu->_registers.pac = 0x00FFFF; snes.cpu->_registers.p.m = true; - cr_assert_eq(snes.cpu->_getImmediateAddrForA(), 0x00FFFF); - cr_assert_eq(snes.cpu->_registers.pac, 0x000000); + REQUIRE(snes.cpu->_getImmediateAddrForA() == 0x00FFFF); + REQUIRE(snes.cpu->_registers.pac == 0x000000); } -Test(AddrMode, Direct) +TEST_CASE("Direct AddrMode", "[AddrMode]") { Init() snes.cartridge->_data[0] = 0x15; snes.cpu->_registers.pac = 0x808000; snes.cpu->_registers.d = 0x1000; - cr_assert_eq(snes.cpu->_getDirectAddr(), 0x1015, "Returned address was %x but was expecting 0x1015.", snes.cpu->_getDirectAddr()); - cr_assert_eq(snes.cpu->_registers.pac, 0x808001); + REQUIRE(snes.cpu->_getDirectAddr() == 0x1015); + REQUIRE(snes.cpu->_registers.pac == 0x808001); } -Test(AddrMode, Absolute) +TEST_CASE("Absolute AddrMode", "[AddrMode]") { Init() snes.cartridge->_data[0] = 0x1C; snes.cartridge->_data[1] = 0x90; snes.cpu->_registers.pac = 0x808000; snes.cpu->_registers.dbr = 0x88; - cr_assert_eq(snes.cpu->_getAbsoluteAddr(), 0x88901C, "Returned address was %x but was expecting 0x88901C.", snes.cpu->_getAbsoluteAddr()); - cr_assert_eq(snes.cpu->_registers.pac, 0x808002); + REQUIRE(snes.cpu->_getAbsoluteAddr() == 0x88901C); + REQUIRE(snes.cpu->_registers.pac == 0x808002); } -Test(AddrMode, AbsoluteLong) +TEST_CASE("AbsoluteLong AddrMode", "[AddrMode]") { Init() snes.cartridge->_data[0] = 0x1C; @@ -74,11 +72,11 @@ Test(AddrMode, AbsoluteLong) snes.cartridge->_data[2] = 0xFF; snes.cpu->_registers.pac = 0x808000; snes.cpu->_registers.dbr = 0x88; - cr_assert_eq(snes.cpu->_getAbsoluteLongAddr(), 0xFF901C, "Returned address was %x but was expecting 0xFF901C.", snes.cpu->_getAbsoluteLongAddr()); - cr_assert_eq(snes.cpu->_registers.pac, 0x808003); + REQUIRE(snes.cpu->_getAbsoluteLongAddr() == 0xFF901C); + REQUIRE(snes.cpu->_registers.pac == 0x808003); } -Test(AddrMode, DirectIndirectIndexed) +TEST_CASE("DirectIndirectIndexed AddrMode", "[AddrMode]") { Init() snes.cartridge->_data[0] = 0x10; @@ -88,12 +86,11 @@ Test(AddrMode, DirectIndirectIndexed) snes.cpu->_registers.dbr = 0x80; snes.cpu->_registers.y = 0x0001; snes.cpu->_registers.d = 0x1000; - cr_assert_eq(snes.cpu->_getDirectIndirectIndexedYAddr(), 0x804031, "Returned address was %x but was expecting 0x804031.", - snes.cpu->_getDirectIndirectIndexedYAddr()); - cr_assert_eq(snes.cpu->_registers.pac, 0x808001); + REQUIRE(snes.cpu->_getDirectIndirectIndexedYAddr() == 0x804031); + REQUIRE(snes.cpu->_registers.pac == 0x808001); } -Test(AddrMode, DirectIndirectIndexedLong) +TEST_CASE("DirectIndirectIndexedLong AddrMode", "[AddrMode]") { Init() snes.cpu->_registers.pac = 0x808000; @@ -102,12 +99,11 @@ Test(AddrMode, DirectIndirectIndexedLong) snes.wram->_data[0x1010] = 0x30; snes.wram->_data[0x1011] = 0x40; snes.wram->_data[0x1012] = 0x23; - cr_assert_eq(snes.cpu->_getDirectIndirectIndexedYLongAddr(), 0x234030, "Returned address was %x but was expecting 0x234030.", - snes.cpu->_getDirectIndirectIndexedYLongAddr()); - cr_assert_eq(snes.cpu->_registers.pac, 0x808001); + REQUIRE(snes.cpu->_getDirectIndirectIndexedYLongAddr() == 0x234030); + REQUIRE(snes.cpu->_registers.pac == 0x808001); } -Test(AddrMode, DirectIndexedIndirect) +TEST_CASE("DirectIndexedIndirect AddrMode", "[AddrMode]") { Init() snes.cartridge->_data[0] = 0x10; @@ -117,34 +113,33 @@ Test(AddrMode, DirectIndexedIndirect) snes.wram->_data[0x1013] = 0x40; snes.cpu->_registers.dbr = 0x80; snes.cpu->_registers.pac = 0x808000; - cr_assert_eq(snes.cpu->_getDirectIndirectIndexedXAddr(), 0x804030, "Returned address was %x but was expecting 0x804030.", - snes.cpu->_getDirectIndirectIndexedXAddr()); - cr_assert_eq(snes.cpu->_registers.pac, 0x808001); + REQUIRE(snes.cpu->_getDirectIndirectIndexedXAddr() == 0x804030); + REQUIRE(snes.cpu->_registers.pac == 0x808001); } -Test(AddrMode, DirectIndexedByX) +TEST_CASE("DirectIndexedByX AddrMode", "[AddrMode]") { Init() snes.cartridge->_data[0] = 0x10; snes.cpu->_registers.d = 0x1000; snes.cpu->_registers.x = 0x0002; snes.cpu->_registers.pac = 0x808000; - cr_assert_eq(snes.cpu->_getDirectIndexedByXAddr(), 0x1012, "Returned address was %x but was expecting 0x1012.", snes.cpu->_getDirectIndexedByXAddr()); - cr_assert_eq(snes.cpu->_registers.pac, 0x808001); + REQUIRE(snes.cpu->_getDirectIndexedByXAddr() == 0x1012); + REQUIRE(snes.cpu->_registers.pac == 0x808001); } -Test(AddrMode, DirectIndexedByY) +TEST_CASE("DirectIndexedByY AddrMode", "[AddrMode]") { Init() snes.cartridge->_data[0] = 0x10; snes.cpu->_registers.d = 0x1000; snes.cpu->_registers.y = 0x0002; snes.cpu->_registers.pac = 0x808000; - cr_assert_eq(snes.cpu->_getDirectIndexedByYAddr(), 0x1012, "Returned address was %x but was expecting 0x1012.", snes.cpu->_getDirectIndexedByYAddr()); - cr_assert_eq(snes.cpu->_registers.pac, 0x808001); + REQUIRE(snes.cpu->_getDirectIndexedByYAddr() == 0x1012); + REQUIRE(snes.cpu->_registers.pac == 0x808001); } -Test(AddrMode, AbsoluteIndexByX) +TEST_CASE("AbsoluteIndexByX AddrMode", "[AddrMode]") { Init() snes.cpu->_registers.pac = 0x808000; @@ -152,11 +147,11 @@ Test(AddrMode, AbsoluteIndexByX) snes.cartridge->_data[1] = 0xAC; snes.cpu->_registers.dbr = 0xEF; snes.cpu->_registers.x = 0x0005; - cr_assert_eq(snes.cpu->_getAbsoluteIndexedByXAddr(), 0xEFAC15, "Returned address was %x but was expecting 0xEFAC15.", snes.cpu->_getAbsoluteIndexedByXAddr()); - cr_assert_eq(snes.cpu->_registers.pac, 0x808002); + REQUIRE(snes.cpu->_getAbsoluteIndexedByXAddr() == 0xEFAC15); + REQUIRE(snes.cpu->_registers.pac == 0x808002); } -Test(AddrMode, AbsoluteIndexByY) +TEST_CASE("AbsoluteIndexByY AddrMode", "[AddrMode]") { Init() snes.cpu->_registers.pac = 0x808000; @@ -164,11 +159,11 @@ Test(AddrMode, AbsoluteIndexByY) snes.cartridge->_data[1] = 0xAC; snes.cpu->_registers.dbr = 0xEF; snes.cpu->_registers.y = 0x0005; - cr_assert_eq(snes.cpu->_getAbsoluteIndexedByYAddr(), 0xEFAC15, "Returned address was %x but was expecting 0xEFAC15.", snes.cpu->_getAbsoluteIndexedByYAddr()); - cr_assert_eq(snes.cpu->_registers.pac, 0x808002); + REQUIRE(snes.cpu->_getAbsoluteIndexedByYAddr() == 0xEFAC15); + REQUIRE(snes.cpu->_registers.pac == 0x808002); } -Test(AddrMode, AbsoluteLongIndexByX) +TEST_CASE("AbsoluteLongIndexByX AddrMode", "[AddrMode]") { Init() snes.cpu->_registers.pac = 0x808000; @@ -176,52 +171,51 @@ Test(AddrMode, AbsoluteLongIndexByX) snes.cartridge->_data[1] = 0xAC; snes.cartridge->_data[2] = 0xEF; snes.cpu->_registers.x = 0x0005; - cr_assert_eq(snes.cpu->_getAbsoluteIndexedByXLongAddr(), 0xEFAC15, "Returned address was %x but was expecting 0xEFAC15.", - snes.cpu->_getAbsoluteIndexedByXLongAddr()); - cr_assert_eq(snes.cpu->_registers.pac, 0x808003); + REQUIRE(snes.cpu->_getAbsoluteIndexedByXLongAddr() == 0xEFAC15); + REQUIRE(snes.cpu->_registers.pac == 0x808003); } -//Test(AddrMode, ProgramCounterRelativePositive) +//TEST_CASE("ProgramCounterRelativePositive AddrMode", "[AddrMode]") //{ // Init() // snes.cpu->_registers.pac = 0x808010; // snes.cartridge->_data[0x10] = 0x15; -// cr_assert_eq(snes.cpu->_getProgramCounterRelativeAddr(), 0x808025, "Returned address was %x but was expecting 0x808025.", snes.cpu->_getProgramCounterRelativeAddr()); -// cr_assert_eq(snes.cpu->_registers.pac, 0x808011); +// REQUIRE(snes.cpu->_getProgramCounterRelativeAddr() == 0x808025); +// REQUIRE(snes.cpu->_registers.pac == 0x808011); //} // -//Test(AddrMode, ProgramCounterRelativeNegative) +//TEST_CASE("ProgramCounterRelativeNegative AddrMode", "[AddrMode]") //{ // Init() // snes.cpu->_registers.pac = 0x808010; // snes.cartridge->_data[0x10] = -0x15; -// cr_assert_eq(snes.cpu->_getProgramCounterRelativeAddr(), 0x807FFB, "Returned address was %x but was expecting 0x807FFB.", snes.cpu->_getProgramCounterRelativeAddr()); -// cr_assert_eq(snes.cpu->_registers.pac, 0x808011); +// REQUIRE(snes.cpu->_getProgramCounterRelativeAddr() == 0x807FFB); +// REQUIRE(snes.cpu->_registers.pac == 0x808011); //} // -//Test(AddrMode, ProgramCounterRelativeLongPositive) +//TEST_CASE("ProgramCounterRelativeLongPositive AddrMode", "[AddrMode]") //{ // Init() // snes.cpu->_registers.pac = 0x808010; // snes.cartridge->_data[0x10] = 0x15; // snes.cartridge->_data[0x11] = 0x10; // auto addr = snes.cpu->_getProgramCounterRelativeLongAddr(); -// cr_assert_eq(addr, 0x809025, "Returned address was %x but was expecting 0x809025.", addr); -// cr_assert_eq(snes.cpu->_registers.pac, 0x808012); +// REQUIRE(addr == 0x809025); +// REQUIRE(snes.cpu->_registers.pac == 0x808012); //} // -//Test(AddrMode, ProgramCounterRelativeLongNegative) +//TEST_CASE("ProgramCounterRelativeLongNegative AddrMode", "[AddrMode]") //{ // Init() // snes.cpu->_registers.pac = 0x808010; // snes.cartridge->_data[0x10] = 0x10; // snes.cartridge->_data[0x11] = -0x15; // auto addr = snes.cpu->_getProgramCounterRelativeLongAddr(); -// cr_assert_eq(addr, 0x806B00, "Returned address was %x but was expecting 0x806B00.", addr); -// cr_assert_eq(snes.cpu->_registers.pac, 0x808012); +// REQUIRE(addr == 0x806B00); +// REQUIRE(snes.cpu->_registers.pac == 0x808012); //} -Test(AddrMode, AbsoluteIndirect) +TEST_CASE("AbsoluteIndirect AddrMode", "[AddrMode]") { Init() snes.cpu->_registers.pac = 0x808000; @@ -230,11 +224,11 @@ Test(AddrMode, AbsoluteIndirect) snes.wram->_data[0x01AB] = 0xEF; snes.wram->_data[0x01AC] = 0x01; auto addr = snes.cpu->_getAbsoluteIndirectAddr(); - cr_assert_eq(addr, 0x01EF, "Returned address was %x but was expecting 0x01EF.", addr); - cr_assert_eq(snes.cpu->_registers.pac, 0x808002); + REQUIRE(addr == 0x01EF); + REQUIRE(snes.cpu->_registers.pac == 0x808002); } -Test(AddrMode, AbsoluteIndexedIndirect) +TEST_CASE("AbsoluteIndexedIndirect AddrMode", "[AddrMode]") { Init() snes.cpu->_registers.pac = 0x808000; @@ -244,11 +238,11 @@ Test(AddrMode, AbsoluteIndexedIndirect) snes.wram->_data[0x01AD] = 0xEF; snes.wram->_data[0x01AE] = 0x01; auto addr = snes.cpu->_getAbsoluteIndirectIndexedByXAddr(); - cr_assert_eq(addr, 0x01EF, "Returned address was %x but was expecting 0x01EF.", addr); - cr_assert_eq(snes.cpu->_registers.pac, 0x808002); + REQUIRE(addr == 0x01EF); + REQUIRE(snes.cpu->_registers.pac == 0x808002); } -Test(AddrMode, DirectIndirect) +TEST_CASE("DirectIndirect AddrMode", "[AddrMode]") { Init() snes.cpu->_registers.pac = 0x808000; @@ -258,11 +252,11 @@ Test(AddrMode, DirectIndirect) snes.wram->_data[0x1012] = 0x01; snes.cpu->_registers.dbr = 0x88; auto addr = snes.cpu->_getDirectIndirectAddr(); - cr_assert_eq(addr, 0x8801EF, "Returned address was %x but was expecting 0x8801EF.", addr); - cr_assert_eq(snes.cpu->_registers.pac, 0x808001); + REQUIRE(addr == 0x8801EF); + REQUIRE(snes.cpu->_registers.pac == 0x808001); } -Test(AddrMode, DirectIndirectLong) +TEST_CASE("DirectIndirectLong AddrMode", "[AddrMode]") { Init() snes.cpu->_registers.pac = 0x808000; @@ -272,22 +266,22 @@ Test(AddrMode, DirectIndirectLong) snes.wram->_data[0x1017] = 0x01; snes.wram->_data[0x1018] = 0x88; auto addr = snes.cpu->_getDirectIndirectLongAddr(); - cr_assert_eq(addr, 0x8801EF, "Returned address was %x but was expecting 0x8801EF.", addr); - cr_assert_eq(snes.cpu->_registers.pac, 0x808001); + REQUIRE(addr == 0x8801EF); + REQUIRE(snes.cpu->_registers.pac == 0x808001); } -Test(AddrMode, StackRelative) +TEST_CASE("StackRelative AddrMode", "[AddrMode]") { Init() snes.cpu->_registers.pac = 0x808000; snes.cartridge->_data[0] = 0x06; snes.cpu->_registers.s = 0x1010; auto addr = snes.cpu->_getStackRelativeAddr(); - cr_assert_eq(addr, 0x1016, "Returned address was %x but was expecting 0x1016.", addr); - cr_assert_eq(snes.cpu->_registers.pac, 0x808001); + REQUIRE(addr == 0x1016); + REQUIRE(snes.cpu->_registers.pac == 0x808001); } -Test(AddrMode, StackRelativeIndirectIndexed) +TEST_CASE("StackRelativeIndirectIndexed AddrMode", "[AddrMode]") { Init() snes.cpu->_registers.pac = 0x808000; @@ -296,6 +290,6 @@ Test(AddrMode, StackRelativeIndirectIndexed) snes.cpu->_registers.y = 0x5; snes.cpu->_registers.dbr = 0x88; auto addr = snes.cpu->_getStackRelativeIndirectIndexedYAddr(); - cr_assert_eq(addr, 0x88101B, "Returned address was %x but was expecting 0x88101B.", addr); - cr_assert_eq(snes.cpu->_registers.pac, 0x808001); + REQUIRE(addr == 0x88101B); + REQUIRE(snes.cpu->_registers.pac == 0x808001); } \ No newline at end of file diff --git a/tests/CPU/testBits.cpp b/tests/CPU/testBits.cpp index a4bd5de..0c7ea30 100644 --- a/tests/CPU/testBits.cpp +++ b/tests/CPU/testBits.cpp @@ -2,26 +2,26 @@ // Created by anonymus-raccoon on 2/20/20. // -#include +#include #include #include #include "../tests.hpp" #include "../../sources/SNES.hpp" using namespace ComSquare; -Test(AND, emulation) +TEST_CASE("emulation AND", "[AND]") { Init() snes.wram->_data[0] = 0x00; snes.cpu->_registers.a = 0xFF; snes.cpu->_isEmulationMode = true; snes.cpu->AND(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0x00, "The flags should be 0x00 but it was %x", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); + REQUIRE(snes.cpu->_registers.a == 0x00); + REQUIRE(snes.cpu->_registers.p.z == true); + REQUIRE(snes.cpu->_registers.p.n == false); } -Test(AND, nativeNegative) +TEST_CASE("nativeNegative AND", "[AND]") { Init() snes.wram->_data[0] = 0xF0; @@ -30,35 +30,35 @@ Test(AND, nativeNegative) snes.cpu->_registers.a = 0xFF00; snes.cpu->_isEmulationMode = false; snes.cpu->AND(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0xF000, "The flags should be 0xF000 but it was %x", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); + REQUIRE(snes.cpu->_registers.a == 0xF000); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.n == true); } -Test(AND, emulationTest) +TEST_CASE("emulationTest AND", "[AND]") { Init() snes.wram->_data[0] = 0b00110011; snes.cpu->_registers.a = 0b00110111; snes.cpu->_isEmulationMode = true; snes.cpu->AND(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0b00110011, "The flags should be 0b00110011 but it was %x", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); + REQUIRE(snes.cpu->_registers.a == 0b00110011); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.n == false); } -Test(TSB, emulationTest) +TEST_CASE("emulationTest TSB", "[TSB]") { Init() snes.wram->_data[0] = 0b00110011; snes.cpu->_registers.a = 0b00110111; snes.cpu->_registers.p.m = true; snes.cpu->TSB(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.wram->_data[0], 0b00110111, "The data in ram should be 0b00110111 but it was %x", snes.wram->_data[0]); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); + REQUIRE(snes.wram->_data[0] == 0b00110111); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TSB, nativeTest) +TEST_CASE("nativeTest TSB", "[TSB]") { Init() snes.wram->_data[0] = 0xF0; @@ -66,12 +66,12 @@ Test(TSB, nativeTest) snes.cpu->_registers.a = 0x8008; snes.cpu->_registers.p.m = false; snes.cpu->TSB(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.wram->_data[0], 0xF8, "The first data in ram should be 0xF8 but it was %x", snes.wram->_data[0]); - cr_assert_eq(snes.wram->_data[1], 0x8F, "The second data in ram should be 0x8F but it was %x", snes.wram->_data[1]); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); + REQUIRE(snes.wram->_data[0] == 0xF8); + REQUIRE(snes.wram->_data[1] == 0x8F); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(BIT, immediate) +TEST_CASE("immediate BIT", "[BIT]") { Init() snes.wram->_data[0] = 0xFF; @@ -81,12 +81,12 @@ Test(BIT, immediate) snes.cpu->_registers.p.v = false; snes.cpu->_registers.p.n = false; snes.cpu->BIT(0x0, ComSquare::CPU::AddressingMode::ImmediateForA); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.v, false, "The overflow flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.v == false); + REQUIRE(snes.cpu->_registers.p.n == false); } -Test(BIT, immediateZero) +TEST_CASE("immediateZero BIT", "[BIT]") { Init() snes.wram->_data[0] = 0x00; @@ -96,12 +96,12 @@ Test(BIT, immediateZero) snes.cpu->_registers.p.v = true; snes.cpu->_registers.p.n = true; snes.cpu->BIT(0x0, ComSquare::CPU::AddressingMode::ImmediateForA); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.v, true, "The overflow flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); + REQUIRE(snes.cpu->_registers.p.z == true); + REQUIRE(snes.cpu->_registers.p.v == true); + REQUIRE(snes.cpu->_registers.p.n == true); } -Test(BIT, other) +TEST_CASE("other BIT", "[BIT]") { Init() snes.wram->_data[0] = 0x00; @@ -111,113 +111,113 @@ Test(BIT, other) snes.cpu->_registers.p.v = false; snes.cpu->_registers.p.n = false; snes.cpu->BIT(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.v, true, "The overflow flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.v == true); + REQUIRE(snes.cpu->_registers.p.n == true); } -Test(ASL, emulationTest) +TEST_CASE("emulationTest ASL", "[ASL]") { Init() snes.wram->_data[0] = 0b10110011; snes.cpu->_registers.p.m = true; snes.cpu->ASL(0x0, ComSquare::CPU::AddressingMode::Absolute); - cr_assert_eq(snes.wram->_data[0], 0b01100110, "The data in ram should be 0b01100110 but it was %x", snes.wram->_data[0]); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); + REQUIRE(snes.wram->_data[0] == 0b01100110); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.c == true); + REQUIRE(snes.cpu->_registers.p.n == false); } -Test(ASL, nativeTest) +TEST_CASE("nativeTest ASL", "[ASL]") { Init() snes.wram->_data[0] = 0b10110011; snes.wram->_data[1] = 0b10000011; snes.cpu->_registers.p.m = false; snes.cpu->ASL(0x0, ComSquare::CPU::AddressingMode::Absolute); - cr_assert_eq(snes.wram->_data[0], 0b01100110, "The data in ram should be 0b01100110 but it was %x", snes.wram->_data[0]); - cr_assert_eq(snes.wram->_data[1], 0b00000111, "The data in ram should be 0b00000111 but it was %x", snes.wram->_data[1]); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); + REQUIRE(snes.wram->_data[0] == 0b01100110); + REQUIRE(snes.wram->_data[1] == 0b00000111); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.c == true); + REQUIRE(snes.cpu->_registers.p.n == false); } -Test(ASL, accumulator) +TEST_CASE("accumulator ASL", "[ASL]") { Init() snes.cpu->_registers.a = 0b10110011; snes.cpu->_registers.p.m = true; snes.cpu->ASL(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.al, 0b01100110, "The accumulator should be 0b01100110 but it was %x", snes.cpu->_registers.al); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); + REQUIRE(snes.cpu->_registers.al == 0b01100110); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.c == true); + REQUIRE(snes.cpu->_registers.p.n == false); } -Test(LSR, emulationTest) +TEST_CASE("emulationTest LSR", "[LSR]") { Init() snes.wram->_data[0] = 0b01100110; snes.cpu->_registers.p.m = true; snes.cpu->LSR(0x0, ComSquare::CPU::AddressingMode::Absolute); - cr_assert_eq(snes.wram->_data[0], 0b00110011, "The data in ram should be 0b00110011 but it was %x", snes.wram->_data[0]); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); + REQUIRE(snes.wram->_data[0] == 0b00110011); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.c == false); + REQUIRE(snes.cpu->_registers.p.n == false); } -Test(LSR, nativeTest) +TEST_CASE("nativeTest LSR", "[LSR]") { Init() snes.wram->_data[0] = 0b10110011; snes.wram->_data[1] = 0b10000011; snes.cpu->_registers.p.m = false; snes.cpu->LSR(0x0, ComSquare::CPU::AddressingMode::Absolute); - cr_assert_eq(snes.wram->_data[0], 0b11011001, "The data in ram should be 0b11011001 but it was %x", snes.wram->_data[0]); - cr_assert_eq(snes.wram->_data[1], 0b01000001, "The data in ram should be 0b01000001 but it was %x", snes.wram->_data[1]); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); + REQUIRE(snes.wram->_data[0] == 0b11011001); + REQUIRE(snes.wram->_data[1] == 0b01000001); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.c == true); + REQUIRE(snes.cpu->_registers.p.n == false); } -Test(LSR, accumulator) +TEST_CASE("accumulator LSR", "[LSR]") { Init() snes.cpu->_registers.a = 0b10110011; snes.cpu->_registers.p.m = true; snes.cpu->LSR(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.al, 0b01011001, "The accumulator should be 0b01011001 but it was %x", snes.cpu->_registers.al); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); + REQUIRE(snes.cpu->_registers.al == 0b01011001); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.c == true); + REQUIRE(snes.cpu->_registers.p.n == false); } -Test(ROL, emulationTest) +TEST_CASE("emulationTest ROL", "[ROL]") { Init() snes.wram->_data[0] = 0b10110011; snes.cpu->_registers.p.m = true; snes.cpu->ROL(0x0, ComSquare::CPU::AddressingMode::Absolute); - cr_assert_eq(snes.wram->_data[0], 0b01100110, "The data in ram should be 0b01100110 but it was %x", snes.wram->_data[0]); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); + REQUIRE(snes.wram->_data[0] == 0b01100110); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.c == true); + REQUIRE(snes.cpu->_registers.p.n == false); } -Test(ROL, emulationTestWithCarry) +TEST_CASE("emulationTestWithCarry ROL", "[ROL]") { Init() snes.wram->_data[0] = 0b10110011; snes.cpu->_registers.p.m = true; snes.cpu->_registers.p.c = true; snes.cpu->ROL(0x0, ComSquare::CPU::AddressingMode::Absolute); - cr_assert_eq(snes.wram->_data[0], 0b01100111, "The data in ram should be 0b01100111 but it was %x", snes.wram->_data[0]); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); + REQUIRE(snes.wram->_data[0] == 0b01100111); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.c == true); + REQUIRE(snes.cpu->_registers.p.n == false); } -Test(ROL, nativeTest) +TEST_CASE("nativeTest ROL", "[ROL]") { Init() snes.wram->_data[0] = 0b10110011; @@ -225,53 +225,53 @@ Test(ROL, nativeTest) snes.cpu->_registers.p.m = false; snes.cpu->_registers.p.c = true; snes.cpu->ROL(0x0, ComSquare::CPU::AddressingMode::Absolute); - cr_assert_eq(snes.wram->_data[0], 0b01100111, "The data in ram should be 0b01100111 but it was %x", snes.wram->_data[0]); - cr_assert_eq(snes.wram->_data[1], 0b00000111, "The data in ram should be 0b00000111 but it was %x", snes.wram->_data[1]); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); + REQUIRE(snes.wram->_data[0] == 0b01100111); + REQUIRE(snes.wram->_data[1] == 0b00000111); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.c == true); + REQUIRE(snes.cpu->_registers.p.n == false); } -Test(ROL, accumulator) +TEST_CASE("accumulator ROL", "[ROL]") { Init() snes.cpu->_registers.a = 0b10110011; snes.cpu->_registers.p.m = true; snes.cpu->_registers.p.c = true; snes.cpu->ROL(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.al, 0b01100111, "The accumulator should be 0b01100111 but it was %x", snes.cpu->_registers.al); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); + REQUIRE(snes.cpu->_registers.al == 0b01100111); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.c == true); + REQUIRE(snes.cpu->_registers.p.n == false); } -Test(ROR, emulationTestWithtoutCarry) +TEST_CASE("emulationTestWithtoutCarry ROR", "[ROR]") { Init() snes.wram->_data[0] = 0b01100110; snes.cpu->_registers.p.m = true; snes.cpu->_registers.p.c = false; snes.cpu->ROR(0x0, ComSquare::CPU::AddressingMode::Absolute); - cr_assert_eq(snes.wram->_data[0], 0b00110011, "The data in ram should be 0b00110011 but it was %x", snes.wram->_data[0]); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); + REQUIRE(snes.wram->_data[0] == 0b00110011); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.c == false); + REQUIRE(snes.cpu->_registers.p.n == false); } -Test(ROR, emulationTest) +TEST_CASE("emulationTest ROR", "[ROR]") { Init() snes.wram->_data[0] = 0b01100110; snes.cpu->_registers.p.m = true; snes.cpu->_registers.p.c = true; snes.cpu->ROR(0x0, ComSquare::CPU::AddressingMode::Absolute); - cr_assert_eq(snes.wram->_data[0], 0b10110011, "The data in ram should be 0b10110011 but it was %x", snes.wram->_data[0]); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); + REQUIRE(snes.wram->_data[0] == 0b10110011); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.c == false); + REQUIRE(snes.cpu->_registers.p.n == false); } -Test(ROR, nativeTest) +TEST_CASE("nativeTest ROR", "[ROR]") { Init() snes.wram->_data[0] = 0b10110011; @@ -279,38 +279,38 @@ Test(ROR, nativeTest) snes.cpu->_registers.p.m = false; snes.cpu->_registers.p.c = true; snes.cpu->ROR(0x0, ComSquare::CPU::AddressingMode::Absolute); - cr_assert_eq(snes.wram->_data[0], 0b11011001, "The data in ram should be 0b11011001 but it was %x", snes.wram->_data[0]); - cr_assert_eq(snes.wram->_data[1], 0b11000001, "The data in ram should be 0b11000001 but it was %x", snes.wram->_data[1]); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); + REQUIRE(snes.wram->_data[0] == 0b11011001); + REQUIRE(snes.wram->_data[1] == 0b11000001); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.c == true); + REQUIRE(snes.cpu->_registers.p.n == false); } -Test(ROR, accumulator) +TEST_CASE("accumulator ROR", "[ROR]") { Init() snes.cpu->_registers.a = 0b10110011; snes.cpu->_registers.p.m = true; snes.cpu->_registers.p.c = true; snes.cpu->ROR(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.al, 0b11011001, "The accumulator should be 0b11011001 but it was %x", snes.cpu->_registers.al); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); + REQUIRE(snes.cpu->_registers.al == 0b11011001); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.c == true); + REQUIRE(snes.cpu->_registers.p.n == false); } -Test(TRB, emulationTest) +TEST_CASE("emulationTest TRB", "[TRB]") { Init() snes.wram->_data[0] = 0xFF; snes.cpu->_registers.a = 0b00110111; snes.cpu->_registers.p.m = true; snes.cpu->TRB(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.wram->_data[0], 0b11001000, "The data in ram should be 0b11001000 but it was %x", snes.wram->_data[0]); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); + REQUIRE(snes.wram->_data[0] == 0b11001000); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TRB, nativeTest) +TEST_CASE("nativeTest TRB", "[TRB]") { Init() snes.wram->_data[0] = 0xF0; @@ -318,18 +318,18 @@ Test(TRB, nativeTest) snes.cpu->_registers.a = 0x0F0F; snes.cpu->_registers.p.m = false; snes.cpu->TRB(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.wram->_data[0], 0xF0, "The first data in ram should be 0xF0 but it was %x", snes.wram->_data[0]); - cr_assert_eq(snes.wram->_data[1], 0x00, "The second data in ram should be 0x00 but it was %x", snes.wram->_data[1]); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); + REQUIRE(snes.wram->_data[0] == 0xF0); + REQUIRE(snes.wram->_data[1] == 0x00); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TRB, zero) +TEST_CASE("zero TRB", "[TRB]") { Init() snes.wram->_data[0] = 0xFF; snes.cpu->_registers.a = 0b0; snes.cpu->_registers.p.m = true; snes.cpu->TRB(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.wram->_data[0], 0xFF, "The data in ram should be 0xFF but it was %x", snes.wram->_data[0]); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set."); + REQUIRE(snes.wram->_data[0] == 0xFF); + REQUIRE(snes.cpu->_registers.p.z == true); } \ No newline at end of file diff --git a/tests/CPU/testDMA.cpp b/tests/CPU/testDMA.cpp index e661701..e08af18 100644 --- a/tests/CPU/testDMA.cpp +++ b/tests/CPU/testDMA.cpp @@ -2,12 +2,12 @@ // Created by anonymus-raccoon on 2/1/21. // -#include +#include #include #include "../tests.hpp" using namespace ComSquare; -Test(DMA, RomToVRAM) +TEST_CASE("RomToVRAM DMA", "[DMA]") { Init() snes.cartridge->_size = 4000000; @@ -25,39 +25,39 @@ Test(DMA, RomToVRAM) snes.bus->write(0x2116, 0); snes.bus->write(0x4301, 0x18); - cr_assert_eq(snes.cpu->_dmaChannels[0]._port, 0x18, "The dma's b port was $%x but it should have been $18.", snes.cpu->_dmaChannels[0]._port); + REQUIRE(snes.cpu->_dmaChannels[0]._port == 0x18); snes.bus->write(0x4304, 0x13); snes.bus->write(0x4303, 0xBE); snes.bus->write(0x4302, 0x00); - cr_assert_eq(snes.cpu->_dmaChannels[0]._aAddress.raw, 0x13BE00, "The dma's a address was $%x but it should have been $13BE00.", snes.cpu->_dmaChannels[0]._aAddress.raw); + REQUIRE(snes.cpu->_dmaChannels[0]._aAddress.raw == 0x13BE00); snes.bus->write(0x4306, 0x08); snes.bus->write(0x4305, 0); - cr_assert_eq(snes.cpu->_dmaChannels[0]._count.raw, 0x0800, "The dma's count was $%x but it should have been $0800.", snes.cpu->_dmaChannels[0]._count.raw); + REQUIRE(snes.cpu->_dmaChannels[0]._count.raw == 0x0800); snes.bus->write(0x4300, 1); - cr_assert_eq(snes.cpu->_dmaChannels[0]._controlRegister.direction, CPU::DMA::AtoB, "Direction should have been 0 (A to B) but it was %x.", snes.cpu->_dmaChannels[0]._controlRegister.direction); - cr_assert_eq(snes.cpu->_dmaChannels[0]._controlRegister._, 0, "The unused byte should be 0."); - cr_assert_eq(snes.cpu->_dmaChannels[0]._controlRegister.increment, 0, "The increment byte should be set to 0."); - cr_assert_eq(snes.cpu->_dmaChannels[0]._controlRegister.fixed, 0, "The increment byte should be set to 0."); - cr_assert_eq(snes.cpu->_dmaChannels[0]._controlRegister.mode, CPU::DMA::TwoToTwo, "The DMA mode should have been TwoToTwo (%%001) but it was) $%x", snes.cpu->_dmaChannels[0]._controlRegister.mode); - cr_assert_eq(snes.cpu->_dmaChannels[0].enabled, false, "The DMA channel should be disabled."); + REQUIRE(snes.cpu->_dmaChannels[0]._controlRegister.direction == CPU::DMA::AtoB); + REQUIRE(snes.cpu->_dmaChannels[0]._controlRegister._ == 0); + REQUIRE(snes.cpu->_dmaChannels[0]._controlRegister.increment == 0); + REQUIRE(snes.cpu->_dmaChannels[0]._controlRegister.fixed == 0); + REQUIRE(snes.cpu->_dmaChannels[0]._controlRegister.mode == CPU::DMA::TwoToTwo); + REQUIRE(snes.cpu->_dmaChannels[0].enabled == false); // Enabling DMA's channel 0 snes.bus->write(0x420B, 1); - cr_assert_eq(snes.cpu->_dmaChannels[0].enabled, true, "The DMA channel should be enabled."); + REQUIRE(snes.cpu->_dmaChannels[0].enabled == true); // TODO There is an overhead of 12-24 cycles for the whole transfer. How should I know how many cycles there is? auto cycles = snes.cpu->_dmaChannels[0].run(1000000); - cr_assert_eq(cycles, 8 + 8 * 0x800, "The dma should take $4008 cycles but it took $%x.", cycles); - cr_assert_eq(snes.cpu->_dmaChannels[0]._count.raw, 0, "The dma count should be 0 but it was $%x.", snes.cpu->_dmaChannels[0]._count.raw); - cr_assert_eq(snes.cpu->_dmaChannels[0]._aAddress.raw, 0x13C600, "The dma count should be $13C600 but it was $%x.", snes.cpu->_dmaChannels[0]._aAddress.raw); - cr_assert_eq(snes.cpu->_dmaChannels[0]._port, 0x18, "The dma count should be $18 but it was $%x.", snes.cpu->_dmaChannels[0]._port); - cr_assert_eq(snes.ppu->_registers._vmadd.vmadd, 0x2400, "The vram address should be $2400 but it was %x.", snes.ppu->_registers._vmadd.vmadd); + REQUIRE(cycles == 8 + 8 * 0x800); + REQUIRE(snes.cpu->_dmaChannels[0]._count.raw == 0); + REQUIRE(snes.cpu->_dmaChannels[0]._aAddress.raw == 0x13C600); + REQUIRE(snes.cpu->_dmaChannels[0]._port == 0x18); + REQUIRE(snes.ppu->_registers._vmadd.vmadd == 0x2400); for(unsigned i = 0; i < 0x400; i++) { uint16_t value = snes.ppu->vram->_data[0x2000 * 2 + i * 2] | (snes.ppu->vram->_data[0x2000 * 2 + i * 2 + 1] << 8); - cr_assert_eq(value, i, "The memory at %x should be %x but it was %x", 0x2000 + i, i, snes.ppu->vram->_data[i]); + REQUIRE(value == i); } - cr_assert_eq(snes.cpu->_dmaChannels[0].enabled, false, "The DMA channel should be disabled."); + REQUIRE(snes.cpu->_dmaChannels[0].enabled == false); } -Test(DMA, VramWrite) +TEST_CASE("VramWrite DMA", "[DMA]") { Init() snes.bus->write(0x2117, 0x20); @@ -65,15 +65,15 @@ Test(DMA, VramWrite) for (unsigned i = 0; i < 0x400; i++) { snes.bus->write(0x2119, i >> 8); snes.bus->write(0x2118, i); - cr_assert_eq(snes.ppu->_registers._vmadd.vmadd, 0x2001 + i, "The vram address was %x but it should have been %x", snes.ppu->_registers._vmadd.vmadd, 0x2001 + i); + REQUIRE(snes.ppu->_registers._vmadd.vmadd == 0x2001 + i); } for(unsigned i = 0; i < 0x400; i++) { uint16_t value = snes.ppu->vram->_data[0x2000 * 2 + i * 2] | (snes.ppu->vram->_data[0x2000 * 2 + i * 2 + 1] << 8); - cr_assert_eq(value, (uint16_t)i, "The memory at %x should be %x but it was %x", 0x2000 + i, (uint16_t)i, value); + REQUIRE(value == (uint16_t)i); } } -Test(DMA, VramWriteInvertedOrder) +TEST_CASE("VramWriteInvertedOrder DMA", "[DMA]") { Init() snes.bus->write(0x2115, 0b10000000); @@ -82,15 +82,15 @@ Test(DMA, VramWriteInvertedOrder) for (unsigned i = 0; i < 0x400; i++) { snes.bus->write(0x2118, i); snes.bus->write(0x2119, i >> 8); - cr_assert_eq(snes.ppu->_registers._vmadd.vmadd, 0x2001 + i, "The vram address was %x but it should have been %x", snes.ppu->_registers._vmadd.vmadd, 0x2001 + i); + REQUIRE(snes.ppu->_registers._vmadd.vmadd == 0x2001 + i); } for(unsigned i = 0; i < 0x400; i++) { uint16_t value = snes.ppu->vram->_data[0x2000 * 2 + i * 2] | (snes.ppu->vram->_data[0x2000 * 2 + i * 2 + 1] << 8); - cr_assert_eq(value, (uint16_t)i, "The memory at %x should be %x but it was %x", 0x2000 + i, (uint16_t)i, value); + REQUIRE(value == (uint16_t)i); } } -Test(DMA, WRamToVRAM) +TEST_CASE("WRamToVRAM DMA", "[DMA]") { Init() for (unsigned i = 0; i < 0x400; i++) { @@ -106,34 +106,34 @@ Test(DMA, WRamToVRAM) snes.bus->write(0x2116, 0); snes.bus->write(0x4301, 0x18); - cr_assert_eq(snes.cpu->_dmaChannels[0]._port, 0x18, "The dma's b port was $%x but it should have been $18.", snes.cpu->_dmaChannels[0]._port); + REQUIRE(snes.cpu->_dmaChannels[0]._port == 0x18); snes.bus->write(0x4304, 0x7E); snes.bus->write(0x4303, 0x00); snes.bus->write(0x4302, 0x00); - cr_assert_eq(snes.cpu->_dmaChannels[0]._aAddress.raw, 0x7E0000, "The dma's a address was $%x but it should have been $7E0000.", snes.cpu->_dmaChannels[0]._aAddress.raw); + REQUIRE(snes.cpu->_dmaChannels[0]._aAddress.raw == 0x7E0000); snes.bus->write(0x4306, 0x08); snes.bus->write(0x4305, 0); - cr_assert_eq(snes.cpu->_dmaChannels[0]._count.raw, 0x0800, "The dma's count was $%x but it should have been $0800.", snes.cpu->_dmaChannels[0]._count.raw); + REQUIRE(snes.cpu->_dmaChannels[0]._count.raw == 0x0800); snes.bus->write(0x4300, 1); - cr_assert_eq(snes.cpu->_dmaChannels[0]._controlRegister.direction, CPU::DMA::AtoB, "Direction should have been 0 (A to B) but it was %x.", snes.cpu->_dmaChannels[0]._controlRegister.direction); - cr_assert_eq(snes.cpu->_dmaChannels[0]._controlRegister._, 0, "The unused byte should be 0."); - cr_assert_eq(snes.cpu->_dmaChannels[0]._controlRegister.increment, 0, "The increment byte should be set to 0."); - cr_assert_eq(snes.cpu->_dmaChannels[0]._controlRegister.fixed, 0, "The increment byte should be set to 0."); - cr_assert_eq(snes.cpu->_dmaChannels[0]._controlRegister.mode, CPU::DMA::TwoToTwo, "The DMA mode should have been TwoToTwo (%%001) but it was) $%x", snes.cpu->_dmaChannels[0]._controlRegister.mode); - cr_assert_eq(snes.cpu->_dmaChannels[0].enabled, false, "The DMA channel should be disabled."); + REQUIRE(snes.cpu->_dmaChannels[0]._controlRegister.direction == CPU::DMA::AtoB); + REQUIRE(snes.cpu->_dmaChannels[0]._controlRegister._ == 0); + REQUIRE(snes.cpu->_dmaChannels[0]._controlRegister.increment == 0); + REQUIRE(snes.cpu->_dmaChannels[0]._controlRegister.fixed == 0); + REQUIRE(snes.cpu->_dmaChannels[0]._controlRegister.mode == CPU::DMA::TwoToTwo); + REQUIRE(snes.cpu->_dmaChannels[0].enabled == false); // Enabling DMA's channel 0 snes.bus->write(0x420B, 1); - cr_assert_eq(snes.cpu->_dmaChannels[0].enabled, true, "The DMA channel should be enabled."); + REQUIRE(snes.cpu->_dmaChannels[0].enabled == true); // TODO There is an overhead of 12-24 cycles for the whole transfer. How should I know how many cycles there is? auto cycles = snes.cpu->_dmaChannels[0].run(1000000); - cr_assert_eq(cycles, 8 + 8 * 0x800, "The dma should take $4008 cycles but it took $%x.", cycles); - cr_assert_eq(snes.cpu->_dmaChannels[0]._count.raw, 0, "The dma count should be 0 but it was $%x.", snes.cpu->_dmaChannels[0]._count.raw); - cr_assert_eq(snes.cpu->_dmaChannels[0]._aAddress.raw, 0x7E0800, "The dma count should be $7E0800 but it was $%x.", snes.cpu->_dmaChannels[0]._aAddress.raw); - cr_assert_eq(snes.cpu->_dmaChannels[0]._port, 0x18, "The dma count should be $18 but it was $%x.", snes.cpu->_dmaChannels[0]._port); - cr_assert_eq(snes.ppu->_registers._vmadd.vmadd, 0x0400, "The vram address should be $400 but it was %x.", snes.ppu->_registers._vmadd.vmadd); + REQUIRE(cycles == 8 + 8 * 0x800); + REQUIRE(snes.cpu->_dmaChannels[0]._count.raw == 0); + REQUIRE(snes.cpu->_dmaChannels[0]._aAddress.raw == 0x7E0800); + REQUIRE(snes.cpu->_dmaChannels[0]._port == 0x18); + REQUIRE(snes.ppu->_registers._vmadd.vmadd == 0x0400); for(unsigned i = 0; i < 0x400; i++) { uint16_t value = snes.ppu->vram->_data[i * 2] | (snes.ppu->vram->_data[i * 2 + 1] << 8); - cr_assert_eq(value, i, "The memory at %x should be %x but it was %x", i, i, snes.ppu->vram->_data[i]); + REQUIRE(value == i); } - cr_assert_eq(snes.cpu->_dmaChannels[0].enabled, false, "The DMA channel should be disabled."); + REQUIRE(snes.cpu->_dmaChannels[0].enabled == false); } \ No newline at end of file diff --git a/tests/CPU/testInternal.cpp b/tests/CPU/testInternal.cpp index a85efbd..338edbe 100644 --- a/tests/CPU/testInternal.cpp +++ b/tests/CPU/testInternal.cpp @@ -2,41 +2,41 @@ // Created by anonymus-raccoon on 2/13/20. // -#include +#include #include #include "../tests.hpp" using namespace ComSquare; -Test(SEP, setall) +TEST_CASE("setall SEP", "[SEP]") { Init() snes.wram->_data[0] = 0xFF; snes.cpu->SEP(0x00, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.p.flags; - cr_assert_eq(data, 0xFF, "The flag should be 0xFF but it was %x", data); + REQUIRE(data == 0xFF); } -Test(SEP, setsome) +TEST_CASE("setsome SEP", "[SEP]") { Init() snes.cpu->_registers.p.flags = 0b01000000; snes.wram->_data[0] = 0b10110101; snes.cpu->SEP(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.p.flags; - cr_assert_eq(data, 0b11110101, "The flag should be 245 but it was %i", data); + REQUIRE(data == 0b11110101); } -Test(REP, resetall) +TEST_CASE("resetall REP", "[REP]") { Init() snes.cpu->_isEmulationMode = false; snes.wram->_data[0] = 0xFF; snes.cpu->REP(0x00, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.p.flags; - cr_assert_eq(data, 0x00, "The flag should be 0x00 but it was %x", data); + REQUIRE(data == 0x00); } -Test(REP, resetsome) +TEST_CASE("resetsome REP", "[REP]") { Init() snes.cpu->_isEmulationMode = false; @@ -44,20 +44,20 @@ Test(REP, resetsome) snes.wram->_data[0] = 0b01000000; snes.cpu->REP(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.p.flags; - cr_assert_eq(data, 0x0, "The flag should be 0 but it was %x", data); + REQUIRE(data == 0x0); } -Test(REP, resetallEmulation) +TEST_CASE("resetallEmulation REP", "[REP]") { Init() snes.cpu->_isEmulationMode = true; snes.wram->_data[0] = 0xFF; snes.cpu->REP(0x00, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.p.flags; - cr_assert_eq(data, 0b00110000, "The flag should be 0b00110000 but it was %x", data); + REQUIRE(data == 0b00110000); } -Test(REP, resetsomeEmulation) +TEST_CASE("resetsomeEmulation REP", "[REP]") { Init() snes.cpu->_isEmulationMode = true; @@ -65,23 +65,23 @@ Test(REP, resetsomeEmulation) snes.wram->_data[0] = 0b01000001; snes.cpu->REP(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.p.flags; - cr_assert_eq(data, 0b00110100, "The flag should be 0b00110100 but it was %x", data); + REQUIRE(data == 0b00110100); } -Test(JSR, jump) +TEST_CASE("jump JSR", "[JSR]") { Init() snes.cpu->_registers.pc = 0xABCD; snes.cpu->_registers.s = 0x0123; snes.cpu->JSR(0xABFF, ComSquare::CPU::AddressingMode::Implied); auto pc = snes.cpu->_registers.pc; - cr_assert_eq(pc, 0xABFF, "The PC should be 0xABFF but it was %x", pc); - cr_assert_eq(snes.cpu->_registers.s, 0x0121, "The stack pointer should be 0x0121 but it was %x", snes.cpu->_registers.s); + REQUIRE(pc == 0xABFF); + REQUIRE(snes.cpu->_registers.s == 0x0121); auto pushed = snes.cpu->_pop16(); - cr_assert_eq(pushed, 0xABCC, "The value pushed to the stack should be 0xABCC but it was %x", pushed); + REQUIRE(pushed == 0xABCC); } -Test(JSL, jump) +TEST_CASE("jump JSL", "[JSL]") { Init() snes.cpu->_registers.pbr = 0xFF; @@ -89,99 +89,99 @@ Test(JSL, jump) snes.cpu->_registers.s = 0x0123; snes.cpu->JSL(0xCDABFF, ComSquare::CPU::AddressingMode::Implied); auto pac = snes.cpu->_registers.pac; - cr_assert_eq(pac, 0xCDABFF, "The PC should be 0xCDABFF but it was %x", pac); - cr_assert_eq(snes.cpu->_registers.s, 0x0120, "The stack pointer should be 0x0120 but it was %x", snes.cpu->_registers.s); + REQUIRE(pac == 0xCDABFF); + REQUIRE(snes.cpu->_registers.s == 0x0120); auto pushed = snes.cpu->_pop16() + (snes.cpu->_pop() << 16u); - cr_assert_eq(pushed, 0xFFABCC, "The value pushed to the stack should be 0xFFABCD but it was %x", pushed); + REQUIRE(pushed == 0xFFABCC); } -Test(PHA, basic) +TEST_CASE("basic PHA", "[PHA]") { Init() snes.cpu->_registers.a = 0xABCD; snes.cpu->_registers.s = 0x02; snes.cpu->_registers.p.m = false; snes.cpu->PHA(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.wram->_data[1], 0xCD, "The second value pushed to the stack should be 0xCD but it was %x", snes.wram->_data[1]); - cr_assert_eq(snes.wram->_data[2], 0xAB, "The first value pushed to the stack should be 0xAB but it was %x", snes.wram->_data[2]); - cr_assert_eq(snes.cpu->_registers.s, 0x0, "The Stack pointer should be equal to 0x0 but it was %x", snes.cpu->_registers.s); + REQUIRE(snes.wram->_data[1] == 0xCD); + REQUIRE(snes.wram->_data[2] == 0xAB); + REQUIRE(snes.cpu->_registers.s == 0x0); } -Test(PHA, 8bits) +TEST_CASE("8bits PHA", "[PHA]") { Init() snes.cpu->_registers.a = 0xCD; snes.cpu->_registers.s = 0x02; snes.cpu->_registers.p.m = false; snes.cpu->PHA(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.wram->_data[1], 0xCD, "The second value pushed to the stack should be 0xCD but it was %x", snes.wram->_data[1]); - cr_assert_eq(snes.cpu->_registers.s, 0x0, "The Stack pointer should be equal to 0x0 but it was %x", snes.cpu->_registers.s); + REQUIRE(snes.wram->_data[1] == 0xCD); + REQUIRE(snes.cpu->_registers.s == 0x0); } -Test(PHB, basic) +TEST_CASE("basic PHB", "[PHB]") { Init() snes.cpu->_registers.dbr = 0xFF; snes.cpu->_registers.s = 0x02; snes.cpu->PHB(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.wram->_data[2], 0xFF, "The first value pushed to the stack should be 0xFF but it was %x", snes.wram->_data[2]); - cr_assert_eq(snes.cpu->_registers.s, 0x1, "The Stack pointer should be equal to 0x1 but it was %x", snes.cpu->_registers.s); + REQUIRE(snes.wram->_data[2] == 0xFF); + REQUIRE(snes.cpu->_registers.s == 0x1); } -Test(PHD, basic) +TEST_CASE("basic PHD", "[PHD]") { Init() snes.cpu->_registers.d = 0xABCD; snes.cpu->_registers.s = 0x02; snes.cpu->PHD(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.wram->_data[1], 0xCD, "The second value pushed to the stack should be 0xCD but it was %x", snes.wram->_data[1]); - cr_assert_eq(snes.wram->_data[2], 0xAB, "The first value pushed to the stack should be 0xAB but it was %x", snes.wram->_data[2]); - cr_assert_eq(snes.cpu->_registers.s, 0x0, "The Stack pointer should be equal to 0x0 but it was %x", snes.cpu->_registers.s); + REQUIRE(snes.wram->_data[1] == 0xCD); + REQUIRE(snes.wram->_data[2] == 0xAB); + REQUIRE(snes.cpu->_registers.s == 0x0); } -Test(PHK, basic) +TEST_CASE("basic PHK", "[PHK]") { Init() snes.cpu->_registers.pbr = 0xFF; snes.cpu->_registers.s = 0x02; snes.cpu->PHK(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.wram->_data[2], 0xFF, "The first value pushed to the stack should be 0xFF but it was %x", snes.wram->_data[2]); - cr_assert_eq(snes.cpu->_registers.s, 0x1, "The Stack pointer should be equal to 0x1 but it was %x", snes.cpu->_registers.s); + REQUIRE(snes.wram->_data[2] == 0xFF); + REQUIRE(snes.cpu->_registers.s == 0x1); } -Test(PHP, basic) +TEST_CASE("basic PHP", "[PHP]") { Init() snes.cpu->_registers.p.flags = 0xFF; snes.cpu->_registers.s = 0x02; snes.cpu->PHP(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.wram->_data[2], 0xFF, "The first value pushed to the stack should be 0xFF but it was %x", snes.wram->_data[2]); - cr_assert_eq(snes.cpu->_registers.s, 0x1, "The Stack pointer should be equal to 0x1 but it was %x", snes.cpu->_registers.s); + REQUIRE(snes.wram->_data[2] == 0xFF); + REQUIRE(snes.cpu->_registers.s == 0x1); } -Test(PHX, basic) +TEST_CASE("basic PHX", "[PHX]") { Init() snes.cpu->_registers.x = 0xABCD; snes.cpu->_registers.s = 0x02; snes.cpu->PHX(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.wram->_data[1], 0xCD, "The second value pushed to the stack should be 0xCD but it was %x", snes.wram->_data[1]); - cr_assert_eq(snes.wram->_data[2], 0xAB, "The first value pushed to the stack should be 0xAB but it was %x", snes.wram->_data[2]); - cr_assert_eq(snes.cpu->_registers.s, 0x0, "The Stack pointer should be equal to 0x0 but it was %x", snes.cpu->_registers.s); + REQUIRE(snes.wram->_data[1] == 0xCD); + REQUIRE(snes.wram->_data[2] == 0xAB); + REQUIRE(snes.cpu->_registers.s == 0x0); } -Test(PHY, basic) +TEST_CASE("basic PHY", "[PHY]") { Init() snes.cpu->_registers.y = 0xABCD; snes.cpu->_registers.s = 0x02; snes.cpu->PHY(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.wram->_data[1], 0xCD, "The second value pushed to the stack should be 0xCD but it was %x", snes.wram->_data[1]); - cr_assert_eq(snes.wram->_data[2], 0xAB, "The first value pushed to the stack should be 0xAB but it was %x", snes.wram->_data[2]); - cr_assert_eq(snes.cpu->_registers.s, 0x0, "The Stack pointer should be equal to 0x0 but it was %x", snes.cpu->_registers.s); + REQUIRE(snes.wram->_data[1] == 0xCD); + REQUIRE(snes.wram->_data[2] == 0xAB); + REQUIRE(snes.cpu->_registers.s == 0x0); } -Test(PLA, basic) +TEST_CASE("basic PLA", "[PLA]") { Init() snes.wram->_data[1] = 0xCD; @@ -190,13 +190,13 @@ Test(PLA, basic) snes.cpu->_registers.p.m = false; snes.cpu->PLA(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.a; - cr_assert_eq(data, 0x7BCD, "The accumulator should be 0x7BCD but it was %x", data); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); - cr_assert_eq(snes.cpu->_registers.s, 0x2, "The Stack pointer should be equal to 0x2 but it was %x", snes.cpu->_registers.s); + REQUIRE(data == 0x7BCD); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.s == 0x2); } -Test(PLA, zero) +TEST_CASE("zero PLA", "[PLA]") { Init() snes.wram->_data[1] = 0x00; @@ -205,13 +205,13 @@ Test(PLA, zero) snes.cpu->_registers.p.m = false; snes.cpu->PLA(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.a; - cr_assert_eq(data, 0x0000, "The accumulator should be 0x0000 but it was %x", data); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); - cr_assert_eq(snes.cpu->_registers.s, 0x2, "The Stack pointer should be equal to 0x2 but it was %x", snes.cpu->_registers.s); + REQUIRE(data == 0x0000); + REQUIRE(snes.cpu->_registers.p.z == true); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.s == 0x2); } -Test(PLA, negative) +TEST_CASE("negative PLA", "[PLA]") { Init() snes.wram->_data[1] = 0x00; @@ -220,13 +220,13 @@ Test(PLA, negative) snes.cpu->_registers.p.m = false; snes.cpu->PLA(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.a; - cr_assert_eq(data, 0xA000, "The accumulator should be 0xA000 but it was %x", data); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag not should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); - cr_assert_eq(snes.cpu->_registers.s, 0x2, "The Stack pointer should be equal to 0x2 but it was %x", snes.cpu->_registers.s); + REQUIRE(data == 0xA000); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.s == 0x2); } -Test(PLX, basic) +TEST_CASE("basic PLX", "[PLX]") { Init() snes.wram->_data[1] = 0xCD; @@ -235,13 +235,13 @@ Test(PLX, basic) snes.cpu->_registers.p.x_b = false; snes.cpu->PLX(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.x; - cr_assert_eq(data, 0x7BCD, "The X register should be 0x7BCD but it was %x", data); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); - cr_assert_eq(snes.cpu->_registers.s, 0x2, "The Stack pointer should be equal to 0x2 but it was %x", snes.cpu->_registers.s); + REQUIRE(data == 0x7BCD); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.s == 0x2); } -Test(PLX, zero) +TEST_CASE("zero PLX", "[PLX]") { Init() snes.wram->_data[1] = 0x00; @@ -250,13 +250,13 @@ Test(PLX, zero) snes.cpu->_registers.p.x_b = false; snes.cpu->PLX(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.x; - cr_assert_eq(data, 0x0000, "The x register should be 0x0000 but it was %x", data); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); - cr_assert_eq(snes.cpu->_registers.s, 0x2, "The Stack pointer should be equal to 0x2 but it was %x", snes.cpu->_registers.s); + REQUIRE(data == 0x0000); + REQUIRE(snes.cpu->_registers.p.z == true); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.s == 0x2); } -Test(PLX, negative) +TEST_CASE("negative PLX", "[PLX]") { Init() snes.wram->_data[1] = 0x00; @@ -265,13 +265,13 @@ Test(PLX, negative) snes.cpu->_registers.p.x_b = false; snes.cpu->PLX(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.x; - cr_assert_eq(data, 0xA000, "The x register should be 0xA000 but it was %x", data); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag not should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); - cr_assert_eq(snes.cpu->_registers.s, 0x2, "The Stack pointer should be equal to 0x2 but it was %x", snes.cpu->_registers.s); + REQUIRE(data == 0xA000); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.s == 0x2); } -Test(PLY, basic) +TEST_CASE("basic PLY", "[PLY]") { Init() snes.wram->_data[1] = 0xCD; @@ -280,13 +280,13 @@ Test(PLY, basic) snes.cpu->_registers.p.x_b = false; snes.cpu->PLY(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.y; - cr_assert_eq(data, 0x7BCD, "The Y register should be 0x7BCD but it was %x", data); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); - cr_assert_eq(snes.cpu->_registers.s, 0x2, "The Stack pointer should be equal to 0x2 but it was %x", snes.cpu->_registers.s); + REQUIRE(data == 0x7BCD); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.s == 0x2); } -Test(PLY, zero) +TEST_CASE("zero PLY", "[PLY]") { Init() snes.wram->_data[1] = 0x00; @@ -295,13 +295,13 @@ Test(PLY, zero) snes.cpu->_registers.p.x_b = false; snes.cpu->PLY(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.y; - cr_assert_eq(data, 0x0000, "The y register should be 0x0000 but it was %x", data); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); - cr_assert_eq(snes.cpu->_registers.s, 0x2, "The Stack pointer should be equal to 0x2 but it was %x", snes.cpu->_registers.s); + REQUIRE(data == 0x0000); + REQUIRE(snes.cpu->_registers.p.z == true); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.s == 0x2); } -Test(PLY, negative) +TEST_CASE("negative PLY", "[PLY]") { Init() snes.wram->_data[1] = 0x00; @@ -310,13 +310,13 @@ Test(PLY, negative) snes.cpu->_registers.p.x_b = false; snes.cpu->PLY(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.y; - cr_assert_eq(data, 0xA000, "The y register should be 0xA000 but it was %x", data); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag not should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); - cr_assert_eq(snes.cpu->_registers.s, 0x2, "The Stack pointer should be equal to 0x2 but it was %x", snes.cpu->_registers.s); + REQUIRE(data == 0xA000); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.s == 0x2); } -Test(PLD, basic) +TEST_CASE("basic PLD", "[PLD]") { Init() snes.wram->_data[1] = 0xCD; @@ -324,13 +324,13 @@ Test(PLD, basic) snes.cpu->_registers.s = 0x00; snes.cpu->PLD(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.d; - cr_assert_eq(data, 0x7BCD, "The D register should be 0x7BCD but it was %x", data); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); - cr_assert_eq(snes.cpu->_registers.s, 0x2, "The Stack pointer should be equal to 0x2 but it was %x", snes.cpu->_registers.s); + REQUIRE(data == 0x7BCD); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.s == 0x2); } -Test(PLD, zero) +TEST_CASE("zero PLD", "[PLD]") { Init() snes.wram->_data[1] = 0x00; @@ -338,13 +338,13 @@ Test(PLD, zero) snes.cpu->_registers.s = 0x00; snes.cpu->PLD(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.d; - cr_assert_eq(data, 0x0000, "The d register should be 0x0000 but it was %x", data); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); - cr_assert_eq(snes.cpu->_registers.s, 0x2, "The Stack pointer should be equal to 0x2 but it was %x", snes.cpu->_registers.s); + REQUIRE(data == 0x0000); + REQUIRE(snes.cpu->_registers.p.z == true); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.s == 0x2); } -Test(PLD, negative) +TEST_CASE("negative PLD", "[PLD]") { Init() snes.wram->_data[1] = 0x00; @@ -352,52 +352,52 @@ Test(PLD, negative) snes.cpu->_registers.s = 0x00; snes.cpu->PLD(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.d; - cr_assert_eq(data, 0xA000, "The D register should be 0xA000 but it was %x", data); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag not should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); - cr_assert_eq(snes.cpu->_registers.s, 0x2, "The Stack pointer should be equal to 0x2 but it was %x", snes.cpu->_registers.s); + REQUIRE(data == 0xA000); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.s == 0x2); } -Test(PLB, basic) +TEST_CASE("basic PLB", "[PLB]") { Init() snes.wram->_data[1] = 0x7D; snes.cpu->_registers.s = 0x00; snes.cpu->PLB(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.dbr; - cr_assert_eq(data, 0x7D, "The DBR should be 0x7D but it was %x", data); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); - cr_assert_eq(snes.cpu->_registers.s, 0x1, "The Stack pointer should be equal to 0x1 but it was %x", snes.cpu->_registers.s); + REQUIRE(data == 0x7D); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.s == 0x1); } -Test(PLB, zero) +TEST_CASE("zero PLB", "[PLB]") { Init() snes.wram->_data[1] = 0x00; snes.cpu->_registers.s = 0x00; snes.cpu->PLB(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.dbr; - cr_assert_eq(data, 0x00, "The dbr should be 0x00 but it was %x", data); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); - cr_assert_eq(snes.cpu->_registers.s, 0x1, "The Stack pointer should be equal to 0x1 but it was %x", snes.cpu->_registers.s); + REQUIRE(data == 0x00); + REQUIRE(snes.cpu->_registers.p.z == true); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.s == 0x1); } -Test(PLB, negative) +TEST_CASE("negative PLB", "[PLB]") { Init() snes.wram->_data[1] = 0xA0; snes.cpu->_registers.s = 0x00; snes.cpu->PLB(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.dbr; - cr_assert_eq(data, 0xA0, "The D register should be 0xA0 but it was %x", data); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag not should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); - cr_assert_eq(snes.cpu->_registers.s, 0x1, "The Stack pointer should be equal to 0x1 but it was %x", snes.cpu->_registers.s); + REQUIRE(data == 0xA0); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.s == 0x1); } -Test(PLP, basic) +TEST_CASE("basic PLP", "[PLP]") { Init() snes.wram->_data[1] = 0x7D; @@ -405,11 +405,11 @@ Test(PLP, basic) snes.cpu->_isEmulationMode = false; snes.cpu->PLP(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.p.flags; - cr_assert_eq(data, 0x7D, "The flags should be 0x7D but it was %x", data); - cr_assert_eq(snes.cpu->_registers.s, 0x1, "The Stack pointer should be equal to 0x1 but it was %x", snes.cpu->_registers.s); + REQUIRE(data == 0x7D); + REQUIRE(snes.cpu->_registers.s == 0x1); } -Test(PLP, emulation) +TEST_CASE("emulation PLP", "[PLP]") { Init() snes.wram->_data[1] = 0x00; @@ -417,67 +417,67 @@ Test(PLP, emulation) snes.cpu->_isEmulationMode = true; snes.cpu->PLP(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.p.flags; - cr_assert_eq(data, 0b00110000, "The flags should be 0b00110000 but it was %x", data); - cr_assert_eq(snes.cpu->_registers.s, 0x1, "The Stack pointer should be equal to 0x1 but it was %x", snes.cpu->_registers.s); + REQUIRE(data == 0b00110000); + REQUIRE(snes.cpu->_registers.s == 0x1); } -Test(CLC, clear) +TEST_CASE("clear CLC", "[CLC]") { Init() snes.cpu->_registers.p.flags = 0xFF; snes.cpu->CLC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flag should not be set"); + REQUIRE(snes.cpu->_registers.p.c == false); } -Test(CLI, clear) +TEST_CASE("clear CLI", "[CLI]") { Init() snes.cpu->_registers.p.flags = 0xFF; snes.cpu->CLI(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.p.i, false, "The interrupt flag should not be set"); + REQUIRE(snes.cpu->_registers.p.i == false); } -Test(CLD, clear) +TEST_CASE("clear CLD", "[CLD]") { Init() snes.cpu->_registers.p.flags = 0xFF; snes.cpu->CLD(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.p.d, false, "The decimal flag should not be set"); + REQUIRE(snes.cpu->_registers.p.d == false); } -Test(CLV, clear) +TEST_CASE("clear CLV", "[CLV]") { Init() snes.cpu->_registers.p.flags = 0xFF; snes.cpu->CLV(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.p.v, false, "The overflow flag should not be set"); + REQUIRE(snes.cpu->_registers.p.v == false); } -Test(SEC, set) +TEST_CASE("set SEC", "[SEC]") { Init() snes.cpu->_registers.p.flags = 0x00; snes.cpu->SEC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flag should be set"); + REQUIRE(snes.cpu->_registers.p.c == true); } -Test(SEI, set) +TEST_CASE("set SEI", "[SEI]") { Init() snes.cpu->_registers.p.flags = 0x00; snes.cpu->SEI(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.p.i, true, "The interrupt disabled flag should be set"); + REQUIRE(snes.cpu->_registers.p.i == true); } -Test(SED, set) +TEST_CASE("set SED", "[SED]") { Init() snes.cpu->_registers.p.flags = 0x00; snes.cpu->SED(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.p.d, true, "The decimal flag should be set"); + REQUIRE(snes.cpu->_registers.p.d == true); } -Test(XCE, enableEmulation) +TEST_CASE("enableEmulation XCE", "[XCE]") { Init() snes.cpu->_isEmulationMode = false; @@ -486,15 +486,15 @@ Test(XCE, enableEmulation) snes.cpu->_registers.xh = 0xFF; snes.cpu->_registers.yh = 0xFF; snes.cpu->XCE(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_isEmulationMode, true, "The e flag should be set"); - cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flag should not be set"); - cr_assert_eq(snes.cpu->_registers.p.m, false, "The memory width flag should be untouched (unset)"); - cr_assert_eq(snes.cpu->_registers.p.x_b, false, "The index width flag should be untouched (unset)"); - cr_assert_eq(snes.cpu->_registers.xh, 0xFF, "The high byte of the x index flag should be untouched (0xFF)"); - cr_assert_eq(snes.cpu->_registers.yh, 0xFF, "The high byte of the y index flag should be untouched (0xFF)"); + REQUIRE(snes.cpu->_isEmulationMode == true); + REQUIRE(snes.cpu->_registers.p.c == false); + REQUIRE(snes.cpu->_registers.p.m == false); + REQUIRE(snes.cpu->_registers.p.x_b == false); + REQUIRE(snes.cpu->_registers.xh == 0xFF); + REQUIRE(snes.cpu->_registers.yh == 0xFF); } -Test(XCE, enableNative) +TEST_CASE("enableNative XCE", "[XCE]") { Init() snes.cpu->_isEmulationMode = true; @@ -502,15 +502,15 @@ Test(XCE, enableNative) snes.cpu->_registers.xh = 0xFF; snes.cpu->_registers.yh = 0xFF; snes.cpu->XCE(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_isEmulationMode, false, "The e flag should be not set"); - cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flag should be set"); - cr_assert_eq(snes.cpu->_registers.p.m, true, "The memory width flag should be set"); - cr_assert_eq(snes.cpu->_registers.p.x_b, true, "The index width flag should be set"); - cr_assert_eq(snes.cpu->_registers.xh, 0, "The high byte of the x index flag should be set to 0"); - cr_assert_eq(snes.cpu->_registers.yh, 0, "The high byte of the y index flag should be set to 0"); + REQUIRE(snes.cpu->_isEmulationMode == false); + REQUIRE(snes.cpu->_registers.p.c == true); + REQUIRE(snes.cpu->_registers.p.m == true); + REQUIRE(snes.cpu->_registers.p.x_b == true); + REQUIRE(snes.cpu->_registers.xh == 0); + REQUIRE(snes.cpu->_registers.yh == 0); } -Test(INX, basic) +TEST_CASE("basic INX", "[INX]") { Init() snes.cpu->_isEmulationMode = true; @@ -518,12 +518,12 @@ Test(INX, basic) snes.cpu->_registers.p.x_b = false; snes.cpu->_registers.x = 0xFF; snes.cpu->INX(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.x, 0x0100, "The x register should be equal to 0x0100 but it was 0x%x.", snes.cpu->_registers.x); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set"); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set"); + REQUIRE(snes.cpu->_registers.x == 0x0100); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.n == false); } -Test(INX, 8bits) +TEST_CASE("8bits INX", "[INX]") { Init() snes.cpu->_isEmulationMode = true; @@ -531,12 +531,12 @@ Test(INX, 8bits) snes.cpu->_registers.p.x_b = true; snes.cpu->_registers.x = 0xFF; snes.cpu->INX(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.x, 0x00, "The x register should be equal to 0x00 but it was 0x%x.", snes.cpu->_registers.x); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set"); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set"); + REQUIRE(snes.cpu->_registers.x == 0x00); + REQUIRE(snes.cpu->_registers.p.z == true); + REQUIRE(snes.cpu->_registers.p.n == false); } -Test(INY, basic) +TEST_CASE("basic INY", "[INY]") { Init() snes.cpu->_isEmulationMode = true; @@ -544,12 +544,12 @@ Test(INY, basic) snes.cpu->_registers.p.x_b = false; snes.cpu->_registers.y = 0xFF; snes.cpu->INY(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.y, 0x0100, "The y register should be equal to 0x0100 but it was 0x%x.", snes.cpu->_registers.y); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set"); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set"); + REQUIRE(snes.cpu->_registers.y == 0x0100); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.n == false); } -Test(INY, 8bits) +TEST_CASE("8bits INY", "[INY]") { Init() snes.cpu->_isEmulationMode = true; @@ -557,12 +557,12 @@ Test(INY, 8bits) snes.cpu->_registers.p.x_b = true; snes.cpu->_registers.y = 0xFF; snes.cpu->INY(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.y, 0x00, "The y register should be equal to 0x00 but it was 0x%x.", snes.cpu->_registers.y); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set"); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set"); + REQUIRE(snes.cpu->_registers.y == 0x00); + REQUIRE(snes.cpu->_registers.p.z == true); + REQUIRE(snes.cpu->_registers.p.n == false); } -Test(CPX, basic) +TEST_CASE("basic CPX", "[CPX]") { Init() snes.cpu->_registers.p.x_b = true; @@ -570,12 +570,12 @@ Test(CPX, basic) snes.cpu->_registers.x = 0xFF; snes.wram->_data[0] = 0xFF; snes.cpu->CPX(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set"); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set"); - cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flag should be set"); + REQUIRE(snes.cpu->_registers.p.z == true); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.c == true); } -Test(CPX, negative) +TEST_CASE("negative CPX", "[CPX]") { Init() snes.cpu->_registers.p.x_b = true; @@ -583,12 +583,12 @@ Test(CPX, negative) snes.cpu->_registers.x = 0x80; snes.wram->_data[0] = 0xFF; snes.cpu->CPX(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set"); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set"); - cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flag should not be set"); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.c == false); } -Test(CPX, 16bits) +TEST_CASE("16bits CPX", "[CPX]") { Init() snes.cpu->_registers.p.flags = 0; @@ -597,12 +597,12 @@ Test(CPX, 16bits) snes.wram->_data[0] = 0x88; snes.wram->_data[1] = 0x98; snes.cpu->CPX(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set"); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set"); - cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flag should not be set"); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.c == false); } -Test(CPY, basic) +TEST_CASE("basic CPY", "[CPY]") { Init() snes.cpu->_registers.p.x_b = true; @@ -610,12 +610,12 @@ Test(CPY, basic) snes.cpu->_registers.y = 0xFF; snes.wram->_data[0] = 0xFF; snes.cpu->CPY(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set"); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set"); - cr_assert_eq(snes.cpu->_registers.p.c, true, "The carry flag should be set"); + REQUIRE(snes.cpu->_registers.p.z == true); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.c == true); } -Test(CPY, negative) +TEST_CASE("negative CPY", "[CPY]") { Init() snes.cpu->_registers.p.x_b = true; @@ -623,307 +623,307 @@ Test(CPY, negative) snes.cpu->_registers.y = 0x80; snes.wram->_data[0] = 0xFF; snes.cpu->CPY(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set"); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set"); - cr_assert_eq(snes.cpu->_registers.p.c, false, "The carry flag should not be set"); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.c == false); } -Test(BCC, basic) +TEST_CASE("basic BCC", "[BCC]") { Init() snes.cpu->_registers.p.c = false; snes.cpu->_registers.pc = 0x80; snes.wram->_data[0] = 0x50; snes.cpu->BCC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0xD0, "The program counter should be equal to 0xD0 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0xD0); } -Test(BCC, negativeJump) +TEST_CASE("negativeJump BCC", "[BCC]") { Init() snes.cpu->_registers.p.c = false; snes.cpu->_registers.pc = 0x80; snes.wram->_data[0] = 0xF0; snes.cpu->BCC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0x70, "The program counter should be equal to 0x70 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0x70); } -Test(BCC, noJump) +TEST_CASE("noJump BCC", "[BCC]") { Init() snes.cpu->_registers.p.c = true; snes.cpu->_registers.pc = 0x80; snes.wram->_data[0] = 0x90; snes.cpu->BCC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0x80, "The program counter should be equal to 0x80 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0x80); } -Test(BCS, basic) +TEST_CASE("basic BCS", "[BCS]") { Init() snes.cpu->_registers.p.c = true; snes.cpu->_registers.pc = 0x80; snes.wram->_data[0] = 0x50; snes.cpu->BCS(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0xD0, "The program counter should be equal to 0xD0 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0xD0); } -Test(BCS, negativeJump) +TEST_CASE("negativeJump BCS", "[BCS]") { Init() snes.cpu->_registers.p.c = true; snes.cpu->_registers.pc = 0x80; snes.wram->_data[0] = 0xF0; snes.cpu->BCS(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0x70, "The program counter should be equal to 0x70 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0x70); } -Test(BCS, noJump) +TEST_CASE("noJump BCS", "[BCS]") { Init() snes.cpu->_registers.p.c = false; snes.cpu->_registers.pc = 0x80; snes.wram->_data[0] = 0x90; snes.cpu->BCS(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0x80, "The program counter should be equal to 0x80 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0x80); } -Test(BEQ, basic) +TEST_CASE("basic BEQ", "[BEQ]") { Init() snes.cpu->_registers.p.z = true; snes.cpu->_registers.pc = 0x80; snes.wram->_data[0] = 0x50; snes.cpu->BEQ(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0xD0, "The program counter should be equal to 0xD0 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0xD0); } -Test(BEQ, negativeJump) +TEST_CASE("negativeJump BEQ", "[BEQ]") { Init() snes.cpu->_registers.p.z = true; snes.cpu->_registers.pc = 0x80; snes.wram->_data[0] = 0xF0; snes.cpu->BEQ(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0x70, "The program counter should be equal to 0x70 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0x70); } -Test(BEQ, noJump) +TEST_CASE("noJump BEQ", "[BEQ]") { Init() snes.cpu->_registers.p.z = false; snes.cpu->_registers.pc = 0x80; snes.wram->_data[0] = 0x90; snes.cpu->BEQ(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0x80, "The program counter should be equal to 0x80 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0x80); } -Test(BNE, basic) +TEST_CASE("basic BNE", "[BNE]") { Init() snes.cpu->_registers.p.z = false; snes.cpu->_registers.pc = 0x80; snes.wram->_data[0] = 0x50; snes.cpu->BNE(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0xD0, "The program counter should be equal to 0xD0 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0xD0); } -Test(BNE, negativeJump) +TEST_CASE("negativeJump BNE", "[BNE]") { Init() snes.cpu->_registers.p.z = false; snes.cpu->_registers.pc = 0x80; snes.wram->_data[0] = 0xF0; snes.cpu->BNE(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0x70, "The program counter should be equal to 0x70 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0x70); } -Test(BNE, noJump) +TEST_CASE("noJump BNE", "[BNE]") { Init() snes.cpu->_registers.p.z = true; snes.cpu->_registers.pc = 0x80; snes.wram->_data[0] = 0x90; snes.cpu->BNE(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0x80, "The program counter should be equal to 0x80 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0x80); } -Test(BMI, basic) +TEST_CASE("basic BMI", "[BMI]") { Init() snes.cpu->_registers.p.n = true; snes.cpu->_registers.pc = 0x80; snes.wram->_data[0] = 0x50; snes.cpu->BMI(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0xD0, "The program counter should be equal to 0xD0 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0xD0); } -Test(BMI, negativeJump) +TEST_CASE("negativeJump BMI", "[BMI]") { Init() snes.cpu->_registers.p.n = true; snes.cpu->_registers.pc = 0x80; snes.wram->_data[0] = 0xF0; snes.cpu->BMI(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0x70, "The program counter should be equal to 0x70 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0x70); } -Test(BMI, noJump) +TEST_CASE("noJump BMI", "[BMI]") { Init() snes.cpu->_registers.p.n = false; snes.cpu->_registers.pc = 0x80; snes.wram->_data[0] = 0x90; snes.cpu->BMI(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0x80, "The program counter should be equal to 0x80 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0x80); } -Test(BPL, basic) +TEST_CASE("basic BPL", "[BPL]") { Init() snes.cpu->_registers.p.n = false; snes.cpu->_registers.pc = 0x80; snes.wram->_data[0] = 0x50; snes.cpu->BPL(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0xD0, "The program counter should be equal to 0xD0 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0xD0); } -Test(BPL, negativeJump) +TEST_CASE("negativeJump BPL", "[BPL]") { Init() snes.cpu->_registers.p.n = false; snes.cpu->_registers.pc = 0x80; snes.wram->_data[0] = 0xF0; snes.cpu->BPL(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0x70, "The program counter should be equal to 0x70 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0x70); } -Test(BPL, noJump) +TEST_CASE("noJump BPL", "[BPL]") { Init() snes.cpu->_registers.p.n = true; snes.cpu->_registers.pc = 0x80; snes.wram->_data[0] = 0x90; snes.cpu->BPL(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0x80, "The program counter should be equal to 0x80 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0x80); } -Test(BRA, basic) +TEST_CASE("basic BRA", "[BRA]") { Init() snes.cpu->_registers.pc = 0x80; snes.wram->_data[0] = 0x50; snes.cpu->BRA(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0xD0, "The program counter should be equal to 0xD0 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0xD0); } -Test(BRA, negativeJump) +TEST_CASE("negativeJump BRA", "[BRA]") { Init() snes.cpu->_registers.pc = 0x80; snes.wram->_data[0] = 0xF0; snes.cpu->BRA(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0x70, "The program counter should be equal to 0x70 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0x70); } -Test(BRL, basic) +TEST_CASE("basic BRL", "[BRL]") { Init() snes.cpu->_registers.pc = 0x8080; snes.wram->_data[0] = 0x00; snes.wram->_data[1] = 0x10; snes.cpu->BRL(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0x9080, "The program counter should be equal to 0x9080 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0x9080); } -Test(BRL, negativeJump) +TEST_CASE("negativeJump BRL", "[BRL]") { Init() snes.cpu->_registers.pc = 0x8080; snes.wram->_data[0] = 0x00; snes.wram->_data[1] = 0xF0; snes.cpu->BRL(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0x7080, "The program counter should be equal to 0x7080 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0x7080); } -Test(BVC, basic) +TEST_CASE("basic BVC", "[BVC]") { Init() snes.cpu->_registers.p.v = false; snes.cpu->_registers.pc = 0x80; snes.wram->_data[0] = 0x50; snes.cpu->BVC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0xD0, "The program counter should be equal to 0xD0 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0xD0); } -Test(BVC, negativeJump) +TEST_CASE("negativeJump BVC", "[BVC]") { Init() snes.cpu->_registers.p.v = false; snes.cpu->_registers.pc = 0x80; snes.wram->_data[0] = 0xF0; snes.cpu->BVC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0x70, "The program counter should be equal to 0x70 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0x70); } -Test(BVC, noJump) +TEST_CASE("noJump BVC", "[BVC]") { Init() snes.cpu->_registers.p.v = true; snes.cpu->_registers.pc = 0x80; snes.wram->_data[0] = 0x90; snes.cpu->BVC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0x80, "The program counter should be equal to 0x80 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0x80); } -Test(BVS, basic) +TEST_CASE("basic BVS", "[BVS]") { Init() snes.cpu->_registers.p.v = true; snes.cpu->_registers.pc = 0x80; snes.wram->_data[0] = 0x50; snes.cpu->BVS(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0xD0, "The program counter should be equal to 0xD0 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0xD0); } -Test(BVS, negativeJump) +TEST_CASE("negativeJump BVS", "[BVS]") { Init() snes.cpu->_registers.p.v = true; snes.cpu->_registers.pc = 0x80; snes.wram->_data[0] = 0xF0; snes.cpu->BVS(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0x70, "The program counter should be equal to 0x70 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0x70); } -Test(BVS, noJump) +TEST_CASE("noJump BVS", "[BVS]") { Init() snes.cpu->_registers.p.v = false; snes.cpu->_registers.pc = 0x80; snes.wram->_data[0] = 0x90; snes.cpu->BVS(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0x80, "The program counter should be equal to 0x80 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0x80); } -Test(JMP, simpleJump) +TEST_CASE("simpleJump JMP", "[JMP]") { Init() snes.cpu->_registers.pc = 0x8000; snes.cpu->JMP(0x1000, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0x1000, "The program counter should be equal to 0x9000 but it was 0x%x.", snes.cpu->_registers.pc); + REQUIRE(snes.cpu->_registers.pc == 0x1000); } -Test(JML, simpleJump) +TEST_CASE("simpleJump JML", "[JML]") { Init() snes.cpu->_registers.pc = 0x8000; snes.cpu->JML(0x10AB00, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pac, 0x10AB00, "The program counter should be equal to 0x10AB00 but it was 0x%x.", snes.cpu->_registers.pac); + REQUIRE(snes.cpu->_registers.pac == 0x10AB00); } -Test(PER, simple) +TEST_CASE("simple PER", "[PER]") { Init() snes.cpu->_registers.pac = 0x008005; @@ -931,29 +931,29 @@ Test(PER, simple) snes.wram->_data[0x0] = 0xFF; snes.wram->_data[0x1] = 0xFF; snes.cpu->PER(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.s, 0x1FFD, "The stack pointer should be equal to 0x1FFD but it was 0x%x.", snes.cpu->_registers.s); + REQUIRE(snes.cpu->_registers.s == 0x1FFD); uint16_t value = snes.cpu->_pop16(); - cr_assert_eq(value, 0x8004, "The pushed value should be equal to 0x8004 but it was 0x%x.", value); + REQUIRE(value == 0x8004); } -Test(PEI, simple) +TEST_CASE("simple PEI", "[PEI]") { Init() snes.cpu->_registers.s = 0x1FFF; snes.cpu->PEI(0xFFFF, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.s, 0x1FFD, "The stack pointer should be equal to 0x1FFD but it was 0x%x.", snes.cpu->_registers.s); + REQUIRE(snes.cpu->_registers.s == 0x1FFD); uint16_t value = snes.cpu->_pop16(); - cr_assert_eq(value, 0xFFFF, "The pushed value should be equal to 0xFFFF but it was 0x%x.", value); + REQUIRE(value == 0xFFFF); } -Test(PEA, simple) +TEST_CASE("simple PEA", "[PEA]") { Init() snes.cpu->_registers.s = 0x1FFF; snes.wram->_data[0x0] = 0xFF; snes.wram->_data[0x1] = 0xFF; snes.cpu->PEA(0xFFFF, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.s, 0x1FFD, "The stack pointer should be equal to 0x1FFD but it was 0x%x.", snes.cpu->_registers.s); + REQUIRE(snes.cpu->_registers.s == 0x1FFD); uint16_t value = snes.cpu->_pop16(); - cr_assert_eq(value, 0xFFFF, "The pushed value should be equal to 0xFFFF but it was 0x%x.", value); + REQUIRE(value == 0xFFFF); } \ No newline at end of file diff --git a/tests/CPU/testInterupts.cpp b/tests/CPU/testInterupts.cpp index 1a3b3e6..9e5c8f1 100644 --- a/tests/CPU/testInterupts.cpp +++ b/tests/CPU/testInterupts.cpp @@ -2,7 +2,7 @@ // Created by anonymus-raccoon on 1/24/20. // -#include +#include #include #include #include "../tests.hpp" @@ -10,7 +10,7 @@ #include "../../sources/Memory/MemoryBus.hpp" using namespace ComSquare; -Test(CPU_emulated, BRK) +TEST_CASE("BRK_emulated CPU][emulated", "[CPU][emulated]") { Init() snes.cpu->_isEmulationMode = true; @@ -19,18 +19,18 @@ Test(CPU_emulated, BRK) snes.cpu->_registers.pc = 0x156u; snes.cpu->_registers.pbr = 0x15; snes.cpu->BRK(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0x123u, "The program counter should be 0x123u but it was 0x%X", snes.cpu->_registers.pc); - cr_assert_eq(snes.cpu->_registers.pbr, 0x0, "The PBR should be 0x0 but it was 0x%X", snes.cpu->_registers.pbr); - cr_assert_eq(snes.cpu->_registers.p.d, false, "The decimal flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.i, true, "The Interrupt disable flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.x_b, true, "The break flag should be set."); + REQUIRE(snes.cpu->_registers.pc == 0x123u); + REQUIRE(snes.cpu->_registers.pbr == 0x0); + REQUIRE(snes.cpu->_registers.p.d == false); + REQUIRE(snes.cpu->_registers.p.i == true); + REQUIRE(snes.cpu->_registers.p.x_b == true); int data = snes.cpu->_pop(); - cr_assert_eq(data, 0xF1, "The Status Registers should be pushed into the stack with the value 0xF1 but it was 0x%X (expected 0xF1).", data); + REQUIRE(data == 0xF1); data = snes.cpu->_pop16(); - cr_assert_eq(data, 0x156u, "The program counter should be incremented by two and pushed on the stack but it was 0x%X (expected 0x158).", data); + REQUIRE(data == 0x156u); } -Test(CPU_native, BRK) +TEST_CASE("BRK_native CPU][native", "[CPU][native]") { Init() snes.cpu->_isEmulationMode = false; @@ -39,19 +39,19 @@ Test(CPU_native, BRK) snes.cpu->_registers.pc = 0x156u; snes.cpu->_registers.pbr = 0x15; snes.cpu->BRK(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0x123u, "The program counter should be 0x123u but it was 0x%X", snes.cpu->_registers.pc); - cr_assert_eq(snes.cpu->_registers.pbr, 0x0, "The PBR should be 0x0 but it was 0x%X", snes.cpu->_registers.pbr); - cr_assert_eq(snes.cpu->_registers.p.d, false, "The decimal flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.i, true, "The Interrupt disable flag should be set."); + REQUIRE(snes.cpu->_registers.pc == 0x123u); + REQUIRE(snes.cpu->_registers.pbr == 0x0); + REQUIRE(snes.cpu->_registers.p.d == false); + REQUIRE(snes.cpu->_registers.p.i == true); int data = snes.cpu->_pop(); - cr_assert_eq(data, 0xF1, "The Status Registers should be pushed into the stack with the value 0xF1 but it was 0x%X (expected 0xF1).", data); + REQUIRE(data == 0xF1); data = snes.cpu->_pop16(); - cr_assert_eq(data, 0x156u, "The program counter should be incremented by two and pushed on the stack but it was 0x%X (expected 0x156).", data); + REQUIRE(data == 0x156u); data = snes.cpu->_pop(); - cr_assert_eq(data, 0x15, "The program bank register should be pushed on the stack but it was 0x%X (expected 0x15).", data); + REQUIRE(data == 0x15); } -Test(CPU_emulated, COP) +TEST_CASE("COP emulated CPU][emulated", "[CPU][emulated]") { Init() snes.cpu->_isEmulationMode = true; @@ -60,18 +60,18 @@ Test(CPU_emulated, COP) snes.cpu->_registers.pc = 0x156u; snes.cpu->_registers.pbr = 0x15; snes.cpu->COP(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0x123u, "The program counter should be 0x123u but it was 0x%X", snes.cpu->_registers.pc); - cr_assert_eq(snes.cpu->_registers.pbr, 0x0, "The PBR should be 0x0 but it was 0x%X", snes.cpu->_registers.pbr); - cr_assert_eq(snes.cpu->_registers.p.d, false, "The decimal flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.i, true, "The Interrupt disable flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.x_b, false, "The break flag should not be set."); + REQUIRE(snes.cpu->_registers.pc == 0x123u); + REQUIRE(snes.cpu->_registers.pbr == 0x0); + REQUIRE(snes.cpu->_registers.p.d == false); + REQUIRE(snes.cpu->_registers.p.i == true); + REQUIRE(snes.cpu->_registers.p.x_b == false); int data = snes.cpu->_pop(); - cr_assert_eq(data, 0x0F, "The Status Registers should be pushed into the stack with the value 0x0F but it was 0x%X (expected 0xF1).", data); + REQUIRE(data == 0x0F); data = snes.cpu->_pop16(); - cr_assert_eq(data, 0x156u, "The program counter should be incremented by two and pushed on the stack but it was 0x%X (expected 0x158).", data); + REQUIRE(data == 0x156u); } -Test(CPU_native, COP) +TEST_CASE("COP native CPU][native", "[CPU][native]") { Init() snes.cpu->_isEmulationMode = false; @@ -80,14 +80,14 @@ Test(CPU_native, COP) snes.cpu->_registers.pc = 0x156u; snes.cpu->_registers.pbr = 0x15; snes.cpu->COP(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.pc, 0x123u, "The program counter should be 0x123u but it was 0x%X", snes.cpu->_registers.pc); - cr_assert_eq(snes.cpu->_registers.pbr, 0x0, "The PBR should be 0x0 but it was 0x%X", snes.cpu->_registers.pbr); - cr_assert_eq(snes.cpu->_registers.p.d, false, "The decimal flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.i, true, "The Interrupt disable flag should be set."); + REQUIRE(snes.cpu->_registers.pc == 0x123u); + REQUIRE(snes.cpu->_registers.pbr == 0x0); + REQUIRE(snes.cpu->_registers.p.d == false); + REQUIRE(snes.cpu->_registers.p.i == true); int data = snes.cpu->_pop(); - cr_assert_eq(data, 0xF1, "The Status Registers should be pushed into the stack with the value 0xF1 but it was 0x%X (expected 0xF1).", data); + REQUIRE(data == 0xF1); data = snes.cpu->_pop16(); - cr_assert_eq(data, 0x156u, "The program counter should be incremented by two and pushed on the stack but it was 0x%X (expected 0x156).", data); + REQUIRE(data == 0x156u); data = snes.cpu->_pop(); - cr_assert_eq(data, 0x15, "The program bank register should be pushed on the stack but it was 0x%X (expected 0x15).", data); + REQUIRE(data == 0x15); } \ No newline at end of file diff --git a/tests/CPU/testStore.cpp b/tests/CPU/testStore.cpp index 4f0af93..fe9cbc7 100644 --- a/tests/CPU/testStore.cpp +++ b/tests/CPU/testStore.cpp @@ -2,84 +2,84 @@ // Created by anonymus-raccoon on 2/12/20. // -#include +#include #include #include #include "../tests.hpp" #include "../../sources/SNES.hpp" using namespace ComSquare; -Test(STA, 8bits) +TEST_CASE("8bits STA", "[STA]") { Init() snes.cpu->_registers.p.m = true; snes.cpu->_registers.a = 0x11; snes.cpu->STA(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.wram->_data[0]; - cr_assert_eq(data, 0x11, "The stored value should be 0x11 but it was 0x%x.", data); + REQUIRE(data == 0x11); } -Test(STA, 16bits) +TEST_CASE("16bits STA", "[STA]") { Init() snes.cpu->_registers.p.m = false; snes.cpu->_registers.a = 0x11AB; snes.cpu->STA(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.wram->_data[0] + (snes.wram->_data[1] << 8u); - cr_assert_eq(data, 0x11AB, "The stored value should be 0x11AB but it was 0x%x.", data); + REQUIRE(data == 0x11AB); } -Test(STX, 8bits) +TEST_CASE("8bits STX", "[STX]") { Init() snes.cpu->_registers.p.x_b = true; snes.cpu->_registers.x = 0x11; snes.cpu->STX(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.wram->_data[0]; - cr_assert_eq(data, 0x11, "The stored value should be 0x11 but it was 0x%x.", data); + REQUIRE(data == 0x11); } -Test(STX, 16bits) +TEST_CASE("16bits STX", "[STX]") { Init() snes.cpu->_registers.p.x_b = false; snes.cpu->_registers.x = 0x11AB; snes.cpu->STX(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.wram->_data[0] + (snes.wram->_data[1] << 8u); - cr_assert_eq(data, 0x11AB, "The stored value should be 0x11AB but it was 0x%x.", data); + REQUIRE(data == 0x11AB); } -Test(STY, 8bits) +TEST_CASE("8bits STY", "[STY]") { Init() snes.cpu->_registers.p.x_b = true; snes.cpu->_registers.y = 0x11; snes.cpu->STY(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.wram->_data[0]; - cr_assert_eq(data, 0x11, "The stored value should be 0x11 but it was 0x%x.", data); + REQUIRE(data == 0x11); } -Test(STY, 16bits) +TEST_CASE("16bits STY", "[STY]") { Init() snes.cpu->_registers.p.x_b = false; snes.cpu->_registers.y = 0x11AB; snes.cpu->STY(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.wram->_data[0] + (snes.wram->_data[1] << 8u); - cr_assert_eq(data, 0x11AB, "The stored value should be 0x11AB but it was 0x%x.", data); + REQUIRE(data == 0x11AB); } -Test(STZ, 8bits) +TEST_CASE("8bits STZ", "[STZ]") { Init() snes.cpu->_registers.p.m = true; snes.wram->_data[0] = 0x11; snes.cpu->STZ(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.wram->_data[0]; - cr_assert_eq(data, 0x00, "The stored value should be 0x00 but it was 0x%x.", data); + REQUIRE(data == 0x00); } -Test(STZ, 16bits) +TEST_CASE("16bits STZ", "[STZ]") { Init() snes.cpu->_registers.p.m = false; @@ -87,34 +87,34 @@ Test(STZ, 16bits) snes.wram->_data[1] = 0x11; snes.cpu->STZ(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.wram->_data[0] + (snes.wram->_data[1] << 8u); - cr_assert_eq(data, 0x00, "The stored value should be 0x00 but it was 0x%x.", data); + REQUIRE(data == 0x00); } -Test(LDX, 8bits) +TEST_CASE("8bits LDX", "[LDX]") { Init() snes.cpu->_registers.p.x_b = true; snes.wram->_data[0] = 0x01; snes.cpu->LDX(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.x; - cr_assert_eq(data, 0x01, "The stored value should be 0x01 but it was 0x%x.", data); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag register should not be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag register should not be set."); + REQUIRE(data == 0x01); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.n == false); } -Test(LDX, 8bitsNegative) +TEST_CASE("8bitsNegative LDX", "[LDX]") { Init() snes.cpu->_registers.p.x_b = true; snes.wram->_data[0] = 0x11; snes.cpu->LDX(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.x; - cr_assert_eq(data, 0x11, "The stored value should be 0x11 but it was 0x%x.", data); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag register should not be set."); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag register should be set."); + REQUIRE(data == 0x11); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.n == true); } -Test(LDX, 8bitsZero) +TEST_CASE("8bitsZero LDX", "[LDX]") { Init() snes.cpu->_registers.p.x_b = true; @@ -122,12 +122,12 @@ Test(LDX, 8bitsZero) snes.wram->_data[1] = 0x11; snes.cpu->LDX(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.x; - cr_assert_eq(data, 0x00, "The stored value should be 0x00 but it was 0x%x.", data); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag register should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag register should not be set."); + REQUIRE(data == 0x00); + REQUIRE(snes.cpu->_registers.p.z == true); + REQUIRE(snes.cpu->_registers.p.n == false); } -Test(LDX, 16bits) +TEST_CASE("16bits LDX", "[LDX]") { Init() snes.cpu->_registers.p.x_b = false; @@ -135,12 +135,12 @@ Test(LDX, 16bits) snes.wram->_data[1] = 001; snes.cpu->LDX(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.x; - cr_assert_eq(data, 0x01AB, "The stored value should be 0x01AB but it was 0x%x.", data); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag register should not be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag register should not be set."); + REQUIRE(data == 0x01AB); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.n == false); } -Test(LDX, 16bitsNegative) +TEST_CASE("16bitsNegative LDX", "[LDX]") { Init() snes.cpu->_registers.p.x_b = false; @@ -148,12 +148,12 @@ Test(LDX, 16bitsNegative) snes.wram->_data[1] = 0x11; snes.cpu->LDX(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.x; - cr_assert_eq(data, 0x11AB, "The stored value should be 0x11AB but it was 0x%x.", data); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag register should not be set."); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag register should be set."); + REQUIRE(data == 0x11AB); + REQUIRE(snes.cpu->_registers.p.z == false); + REQUIRE(snes.cpu->_registers.p.n == true); } -Test(LDX, 16bitsZero) +TEST_CASE("16bitsZero LDX", "[LDX]") { Init() snes.cpu->_registers.p.x_b = false; @@ -161,7 +161,7 @@ Test(LDX, 16bitsZero) snes.wram->_data[1] = 0x00; snes.cpu->LDX(0x0, ComSquare::CPU::AddressingMode::Implied); auto data = snes.cpu->_registers.x; - cr_assert_eq(data, 0x0000, "The stored value should be 0x0000 but it was 0x%x.", data); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag register should be set."); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag register should not be set."); + REQUIRE(data == 0x0000); + REQUIRE(snes.cpu->_registers.p.z == true); + REQUIRE(snes.cpu->_registers.p.n == false); } \ No newline at end of file diff --git a/tests/CPU/testTransfers.cpp b/tests/CPU/testTransfers.cpp index 87497b6..77b3053 100644 --- a/tests/CPU/testTransfers.cpp +++ b/tests/CPU/testTransfers.cpp @@ -2,14 +2,14 @@ // Created by anonymus-raccoon on 2/28/20. // -#include +#include #include #include #include "../tests.hpp" #include "../../sources/SNES.hpp" using namespace ComSquare; -Test(TAX, 16bitsTo16Bits) +TEST_CASE("16bitsTo16Bits TAX", "[TAX]") { Init() snes.cpu->_isEmulationMode = false; @@ -18,12 +18,12 @@ Test(TAX, 16bitsTo16Bits) snes.cpu->_registers.x = 0xABCD; snes.cpu->_registers.a = 0xFEDC; snes.cpu->TAX(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.x, 0xFEDC, "The flags should be 0xFEDC but it was %x", snes.cpu->_registers.x); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); + REQUIRE(snes.cpu->_registers.x == 0xFEDC); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TAX, 16bitsTo8Bits) +TEST_CASE("16bitsTo8Bits TAX", "[TAX]") { Init() snes.cpu->_isEmulationMode = false; @@ -32,12 +32,12 @@ Test(TAX, 16bitsTo8Bits) snes.cpu->_registers.x = 0xFEDC; snes.cpu->_registers.a = 0xAB00; snes.cpu->TAX(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.x, 0xFE00, "The flags should be 0xFE00 but it was %x", snes.cpu->_registers.x); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set."); + REQUIRE(snes.cpu->_registers.x == 0xFE00); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == true); } -Test(TAX, 8bitsTo16Bits) +TEST_CASE("8bitsTo16Bits TAX", "[TAX]") { Init() snes.cpu->_isEmulationMode = false; @@ -46,12 +46,12 @@ Test(TAX, 8bitsTo16Bits) snes.cpu->_registers.x = 0xFEDC; snes.cpu->_registers.a = 0xAB; snes.cpu->TAX(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.x, 0x00AB, "The flags should be 0x00AB but it was %x", snes.cpu->_registers.x); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); + REQUIRE(snes.cpu->_registers.x == 0x00AB); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TAX, 8bitsTo8Bits) +TEST_CASE("8bitsTo8Bits TAX", "[TAX]") { Init() snes.cpu->_isEmulationMode = false; @@ -60,13 +60,13 @@ Test(TAX, 8bitsTo8Bits) snes.cpu->_registers.x = 0xFE; snes.cpu->_registers.a = 0xAB; snes.cpu->TAX(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.x, 0xAB, "The flags should be 0xAB but it was %x", snes.cpu->_registers.x); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should be not set."); + REQUIRE(snes.cpu->_registers.x == 0xAB); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TAY, 16bitsTo16Bits) +TEST_CASE("16bitsTo16Bits TAY", "[TAY]") { Init() snes.cpu->_isEmulationMode = false; @@ -75,12 +75,12 @@ Test(TAY, 16bitsTo16Bits) snes.cpu->_registers.y = 0xABCD; snes.cpu->_registers.a = 0xFEDC; snes.cpu->TAY(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.y, 0xFEDC, "The y register should be 0xFEDC but it was %x", snes.cpu->_registers.y); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); + REQUIRE(snes.cpu->_registers.y == 0xFEDC); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TAY, 16bitsTo8Bits) +TEST_CASE("16bitsTo8Bits TAY", "[TAY]") { Init() snes.cpu->_isEmulationMode = false; @@ -89,12 +89,12 @@ Test(TAY, 16bitsTo8Bits) snes.cpu->_registers.y = 0xFEDC; snes.cpu->_registers.a = 0xAB00; snes.cpu->TAY(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.y, 0xFE00, "The y register should be 0xFE00 but it was %x", snes.cpu->_registers.y); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set."); + REQUIRE(snes.cpu->_registers.y == 0xFE00); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == true); } -Test(TAY, 8bitsTo16Bits) +TEST_CASE("8bitsTo16Bits TAY", "[TAY]") { Init() snes.cpu->_isEmulationMode = false; @@ -103,12 +103,12 @@ Test(TAY, 8bitsTo16Bits) snes.cpu->_registers.y = 0xFEDC; snes.cpu->_registers.a = 0xAB; snes.cpu->TAY(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.y, 0x00AB, "The y register should be 0x00AB but it was %x", snes.cpu->_registers.y); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should not be set."); + REQUIRE(snes.cpu->_registers.y == 0x00AB); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TAY, 8bitsTo8Bits) +TEST_CASE("8bitsTo8Bits TAY", "[TAY]") { Init() snes.cpu->_isEmulationMode = false; @@ -117,36 +117,36 @@ Test(TAY, 8bitsTo8Bits) snes.cpu->_registers.y = 0xFE; snes.cpu->_registers.a = 0xAB; snes.cpu->TAY(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.y, 0xAB, "The y register should be 0xAB but it was %x", snes.cpu->_registers.y); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should be not set."); + REQUIRE(snes.cpu->_registers.y == 0xAB); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TXS, 16bitsIndex) +TEST_CASE("16bitsIndex TXS", "[TXS]") { Init() snes.cpu->_isEmulationMode = false; snes.cpu->_registers.p.x_b = false; snes.cpu->_registers.x = 0xABCD; snes.cpu->TXS(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.s, 0xABCD, "The stack pointer should be 0xABCD but it was %x", snes.cpu->_registers.s); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should be not set."); + REQUIRE(snes.cpu->_registers.s == 0xABCD); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TXS, 8bitsIndex) +TEST_CASE("8bitsIndex TXS", "[TXS]") { Init() snes.cpu->_isEmulationMode = false; snes.cpu->_registers.p.x_b = true; snes.cpu->_registers.x = 0xABCD; snes.cpu->TXS(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.s, 0x00CD, "The stack pointer should be 0x00CD but it was %x", snes.cpu->_registers.s); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should be not set."); + REQUIRE(snes.cpu->_registers.s == 0x00CD); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TCD, emulationMode) +TEST_CASE("emulationMode TCD", "[TCD]") { Init() snes.cpu->_isEmulationMode = true; @@ -154,12 +154,12 @@ Test(TCD, emulationMode) snes.cpu->_registers.d = 0x5656; snes.cpu->_registers.a = 0xABCD; snes.cpu->TCD(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.d, 0xABCD, "The direct page should be 0xABCD but it was %x", snes.cpu->_registers.d); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should be not set."); + REQUIRE(snes.cpu->_registers.d == 0xABCD); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TCD, zero) +TEST_CASE("zero TCD", "[TCD]") { Init() snes.cpu->_isEmulationMode = true; @@ -167,12 +167,12 @@ Test(TCD, zero) snes.cpu->_registers.d = 0x5656; snes.cpu->_registers.a = 0x0; snes.cpu->TCD(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.d, 0, "The direct page should be 0x0 but it was %x", snes.cpu->_registers.d); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set."); + REQUIRE(snes.cpu->_registers.d == 0); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == true); } -Test(TCS, emulationMode) +TEST_CASE("emulationMode TCS", "[TCS]") { Init() snes.cpu->_isEmulationMode = true; @@ -180,10 +180,10 @@ Test(TCS, emulationMode) snes.cpu->_registers.s = 0x0156; snes.cpu->_registers.a = 0xABCD; snes.cpu->TCS(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.s, 0x01CD, "The stack pointer should be 0x01CD but it was %x", snes.cpu->_registers.s); + REQUIRE(snes.cpu->_registers.s == 0x01CD); } -Test(TCS, native) +TEST_CASE("native TCS", "[TCS]") { Init() snes.cpu->_isEmulationMode = false; @@ -191,10 +191,10 @@ Test(TCS, native) snes.cpu->_registers.s = 0x0156; snes.cpu->_registers.a = 0xABCD; snes.cpu->TCS(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.s, 0xABCD, "The stack pointer should be 0xABCD but it was %x", snes.cpu->_registers.s); + REQUIRE(snes.cpu->_registers.s == 0xABCD); } -Test(TDC, emulationMode) +TEST_CASE("emulationMode TDC", "[TDC]") { Init() snes.cpu->_isEmulationMode = true; @@ -202,12 +202,12 @@ Test(TDC, emulationMode) snes.cpu->_registers.d = 0xABCD; snes.cpu->_registers.a = 0x5656; snes.cpu->TDC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0xABCD, "The accumulator should be 0xABCD but it was %x", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should be not set."); + REQUIRE(snes.cpu->_registers.a == 0xABCD); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TDC, zero) +TEST_CASE("zero TDC", "[TDC]") { Init() snes.cpu->_isEmulationMode = true; @@ -215,12 +215,12 @@ Test(TDC, zero) snes.cpu->_registers.d = 0x0; snes.cpu->_registers.a = 0x5656; snes.cpu->TDC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0, "The accumulator should be 0x0 but it was %x", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set."); + REQUIRE(snes.cpu->_registers.a == 0); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == true); } -Test(TSC, emulationMode) +TEST_CASE("emulationMode TSC", "[TSC]") { Init() snes.cpu->_isEmulationMode = true; @@ -228,12 +228,12 @@ Test(TSC, emulationMode) snes.cpu->_registers.s = 0xABCD; snes.cpu->_registers.a = 0x5656; snes.cpu->TSC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0xABCD, "The accumulator should be 0xABCD but it was %x", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should be not set."); + REQUIRE(snes.cpu->_registers.a == 0xABCD); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TSC, zero) +TEST_CASE("zero TSC", "[TSC]") { Init() snes.cpu->_isEmulationMode = true; @@ -241,12 +241,12 @@ Test(TSC, zero) snes.cpu->_registers.s = 0x0; snes.cpu->_registers.a = 0x5656; snes.cpu->TSC(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0, "The accumulator should be 0x0 but it was %x", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, true, "The zero flag should be set."); + REQUIRE(snes.cpu->_registers.a == 0); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == true); } -Test(TSX, emulationMode) +TEST_CASE("emulationMode TSX", "[TSX]") { Init() snes.cpu->_isEmulationMode = true; @@ -254,12 +254,12 @@ Test(TSX, emulationMode) snes.cpu->_registers.s = 0xABCD; snes.cpu->_registers.x = 0x5656; snes.cpu->TSX(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.x, 0x00CD, "The x index should be 0x00CD but it was %x", snes.cpu->_registers.x); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should be not set."); + REQUIRE(snes.cpu->_registers.x == 0x00CD); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TSX, native) +TEST_CASE("native TSX", "[TSX]") { Init() snes.cpu->_isEmulationMode = false; @@ -267,12 +267,12 @@ Test(TSX, native) snes.cpu->_registers.s = 0x8F00; snes.cpu->_registers.x = 0x5656; snes.cpu->TSX(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.x, 0x8F00, "The x index should be 0x8F00 but it was %x", snes.cpu->_registers.x); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should be not set."); + REQUIRE(snes.cpu->_registers.x == 0x8F00); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TXA, double8bits) +TEST_CASE("double8bits TXA", "[TXA]") { Init() snes.cpu->_isEmulationMode = true; @@ -281,12 +281,12 @@ Test(TXA, double8bits) snes.cpu->_registers.x = 0xABCD; snes.cpu->_registers.a = 0x5656; snes.cpu->TXA(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0x56CD, "The accumulator should be 0x56CD but it was %x", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should be not set."); + REQUIRE(snes.cpu->_registers.a == 0x56CD); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TXA, index8bits) +TEST_CASE("index8bits TXA", "[TXA]") { Init() snes.cpu->_isEmulationMode = false; @@ -295,12 +295,12 @@ Test(TXA, index8bits) snes.cpu->_registers.x = 0x0BCD; snes.cpu->_registers.a = 0x5656; snes.cpu->TXA(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0x00CD, "The accumulator should be 0x00CD but it was %x", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should be not set."); + REQUIRE(snes.cpu->_registers.a == 0x00CD); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TXA, accumulator8bits) +TEST_CASE("accumulator8bits TXA", "[TXA]") { Init() snes.cpu->_isEmulationMode = false; @@ -309,12 +309,12 @@ Test(TXA, accumulator8bits) snes.cpu->_registers.x = 0x0BCD; snes.cpu->_registers.a = 0x5656; snes.cpu->TXA(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0x56CD, "The accumulator should be 0x56CD but it was %x", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should be not set."); + REQUIRE(snes.cpu->_registers.a == 0x56CD); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TXA, double16bits) +TEST_CASE("double16bits TXA", "[TXA]") { Init() snes.cpu->_isEmulationMode = false; @@ -323,13 +323,13 @@ Test(TXA, double16bits) snes.cpu->_registers.x = 0xAB0D; snes.cpu->_registers.a = 0x5656; snes.cpu->TXA(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0xAB0D, "The accumulator should be 0xAB0D but it was %x", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should be not set."); + REQUIRE(snes.cpu->_registers.a == 0xAB0D); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TYA, double8bits) +TEST_CASE("double8bits TYA", "[TYA]") { Init() snes.cpu->_isEmulationMode = true; @@ -338,12 +338,12 @@ Test(TYA, double8bits) snes.cpu->_registers.y = 0xABCD; snes.cpu->_registers.a = 0x5656; snes.cpu->TYA(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0x56CD, "The accumulator should be 0x56CD but it was %x", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should be not set."); + REQUIRE(snes.cpu->_registers.a == 0x56CD); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TYA, index8bits) +TEST_CASE("index8bits TYA", "[TYA]") { Init() snes.cpu->_isEmulationMode = false; @@ -352,12 +352,12 @@ Test(TYA, index8bits) snes.cpu->_registers.y = 0x0BCD; snes.cpu->_registers.a = 0x5656; snes.cpu->TYA(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0x00CD, "The accumulator should be 0x00CD but it was %x", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, false, "The negative flag should not be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should be not set."); + REQUIRE(snes.cpu->_registers.a == 0x00CD); + REQUIRE(snes.cpu->_registers.p.n == false); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TYA, accumulator8bits) +TEST_CASE("accumulator8bits TYA", "[TYA]") { Init() snes.cpu->_isEmulationMode = false; @@ -366,12 +366,12 @@ Test(TYA, accumulator8bits) snes.cpu->_registers.y = 0x0BCD; snes.cpu->_registers.a = 0x5656; snes.cpu->TYA(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0x56CD, "The accumulator should be 0x56CD but it was %x", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should be not set."); + REQUIRE(snes.cpu->_registers.a == 0x56CD); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TYA, double16bits) +TEST_CASE("double16bits TYA", "[TYA]") { Init() snes.cpu->_isEmulationMode = false; @@ -380,12 +380,12 @@ Test(TYA, double16bits) snes.cpu->_registers.y = 0xAB0D; snes.cpu->_registers.a = 0x5656; snes.cpu->TYA(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.a, 0xAB0D, "The accumulator should be 0xAB0D but it was %x", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should be not set."); + REQUIRE(snes.cpu->_registers.a == 0xAB0D); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TXY, emulationMode) +TEST_CASE("emulationMode TXY", "[TXY]") { Init() snes.cpu->_isEmulationMode = true; @@ -393,12 +393,12 @@ Test(TXY, emulationMode) snes.cpu->_registers.x = 0x0BCD; snes.cpu->_registers.y = 0x5656; snes.cpu->TXY(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.y, 0x56CD, "The y index should be 0x56CD but it was %x", snes.cpu->_registers.y); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should be not set."); + REQUIRE(snes.cpu->_registers.y == 0x56CD); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TXY, nativeMode) +TEST_CASE("nativeMode TXY", "[TXY]") { Init() snes.cpu->_isEmulationMode = false; @@ -406,12 +406,12 @@ Test(TXY, nativeMode) snes.cpu->_registers.x = 0xAB0D; snes.cpu->_registers.y = 0x5656; snes.cpu->TXY(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.y, 0xAB0D, "The y index should be 0xAB0D but it was %x", snes.cpu->_registers.y); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should be not set."); + REQUIRE(snes.cpu->_registers.y == 0xAB0D); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TYX, emulationMode) +TEST_CASE("emulationMode TYX", "[TYX]") { Init() snes.cpu->_isEmulationMode = true; @@ -419,12 +419,12 @@ Test(TYX, emulationMode) snes.cpu->_registers.y = 0x0BCD; snes.cpu->_registers.x = 0x5656; snes.cpu->TYX(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.x, 0x56CD, "The x index should be 0x56CD but it was %x", snes.cpu->_registers.x); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should be not set."); + REQUIRE(snes.cpu->_registers.x == 0x56CD); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(TYX, nativeMode) +TEST_CASE("nativeMode TYX", "[TYX]") { Init() snes.cpu->_isEmulationMode = false; @@ -432,12 +432,12 @@ Test(TYX, nativeMode) snes.cpu->_registers.y = 0xAB0D; snes.cpu->_registers.x = 0x5656; snes.cpu->TYX(0x0, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(snes.cpu->_registers.x, 0xAB0D, "The x index should be 0xAB0D but it was %x", snes.cpu->_registers.x); - cr_assert_eq(snes.cpu->_registers.p.n, true, "The negative flag should be set."); - cr_assert_eq(snes.cpu->_registers.p.z, false, "The zero flag should be not set."); + REQUIRE(snes.cpu->_registers.x == 0xAB0D); + REQUIRE(snes.cpu->_registers.p.n == true); + REQUIRE(snes.cpu->_registers.p.z == false); } -Test(MVN, hardCase) +TEST_CASE("hardCase MVN", "[MVN]") { Init() snes.cpu->_registers.a = 0x10; @@ -447,16 +447,16 @@ Test(MVN, hardCase) snes.wram->_data[i] = i; int cycles = snes.cpu->MVN(0x2010, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(cycles, 0x77, "The MVN should take 0x77 cycles but it took %x.", cycles); - cr_assert_eq(snes.cpu->_registers.dbr, 0x20, "The data bank register should be 0x20 but it was %x", snes.cpu->_registers.dbr); - cr_assert_eq(snes.cpu->_registers.a, 0xFFFF, "The c accumulator should be 0xFFFF but it was %x", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.x, 0x0011, "The x index should be 0x0011 but it was %x", snes.cpu->_registers.x); - cr_assert_eq(snes.cpu->_registers.y, 0x1011, "The y index should be 0x1011 but it was %x", snes.cpu->_registers.y); + REQUIRE(cycles == 0x77); + REQUIRE(snes.cpu->_registers.dbr == 0x20); + REQUIRE(snes.cpu->_registers.a == 0xFFFF); + REQUIRE(snes.cpu->_registers.x == 0x0011); + REQUIRE(snes.cpu->_registers.y == 0x1011); for (int i = 0; i < 0x11; i++) - cr_assert_eq(snes.wram->_data[i + 0x1000], i, "The data in ram should be %x but it was %x", i, snes.wram->_data[i + 0x1000]); + REQUIRE(snes.wram->_data[i + 0x1000] == i); } -Test(MVP, hardCase) +TEST_CASE("hardCase MVP", "[MVP]") { Init() snes.cpu->_registers.a = 0x10; @@ -466,11 +466,11 @@ Test(MVP, hardCase) snes.wram->_data[i] = i; int cycles = snes.cpu->MVP(0x2010, ComSquare::CPU::AddressingMode::Implied); - cr_assert_eq(cycles, 0x77, "The MVN should take 0x77 cycles but it took %x.", cycles); - cr_assert_eq(snes.cpu->_registers.dbr, 0x20, "The data bank register should be 0x20 but it was %x", snes.cpu->_registers.dbr); - cr_assert_eq(snes.cpu->_registers.a, 0xFFFF, "The c accumulator should be 0xFFFF but it was %x", snes.cpu->_registers.a); - cr_assert_eq(snes.cpu->_registers.x, 0xFFFF, "The x index should be 0xFFFF but it was %x", snes.cpu->_registers.x); - cr_assert_eq(snes.cpu->_registers.y, 0x0FFF, "The y index should be 0x0FFF but it was %x", snes.cpu->_registers.y); + REQUIRE(cycles == 0x77); + REQUIRE(snes.cpu->_registers.dbr == 0x20); + REQUIRE(snes.cpu->_registers.a == 0xFFFF); + REQUIRE(snes.cpu->_registers.x == 0xFFFF); + REQUIRE(snes.cpu->_registers.y == 0x0FFF); for (int i = 0; i < 0x11; i++) - cr_assert_eq(snes.wram->_data[i + 0x1000], i, "The data in ram should be %x but it was %x", i, snes.wram->_data[i + 0x1000]); + REQUIRE(snes.wram->_data[i + 0x1000] == i); } \ No newline at end of file diff --git a/tests/MainTest.cpp b/tests/MainTest.cpp new file mode 100644 index 0000000..6f2c369 --- /dev/null +++ b/tests/MainTest.cpp @@ -0,0 +1,6 @@ +// +// Created by Zoe Roux on 5/17/21. +// + +#define CATCH_CONFIG_MAIN +#include \ No newline at end of file diff --git a/tests/PPU/testBackground.cpp b/tests/PPU/testBackground.cpp index 75efed0..c6b5077 100644 --- a/tests/PPU/testBackground.cpp +++ b/tests/PPU/testBackground.cpp @@ -2,7 +2,7 @@ // Created by cbihan on 9/29/20. // -#include +#include #include #include #include "../tests.hpp" @@ -12,10 +12,10 @@ using namespace ComSquare; -Test(backgroundGetTilePixelReference, basicTest) +TEST_CASE("basicTest backgroundGetTilePixelReference", "[backgroundGetTilePixelReference]") { Init() snes.bus->write(0x2100, 0b11111111); - cr_assert_eq(snes.ppu->_registers._inidisp.fblank, true); - cr_assert_eq(snes.ppu->_registers._inidisp.brightness, 0xF); + REQUIRE(snes.ppu->_registers._inidisp.fblank == true); + REQUIRE(snes.ppu->_registers._inidisp.brightness == 0xF); } \ No newline at end of file diff --git a/tests/PPU/testPpuRead.cpp b/tests/PPU/testPpuRead.cpp index b569e8d..9fd38c3 100644 --- a/tests/PPU/testPpuRead.cpp +++ b/tests/PPU/testPpuRead.cpp @@ -2,7 +2,7 @@ // Created by cbihan on 2/1/21. // -#include +#include #include #include "../tests.hpp" #include "../../sources/SNES.hpp" @@ -11,7 +11,7 @@ using namespace ComSquare; -Test(PPU_read_1, vram_data_read_full) +TEST_CASE("vram_data_read_full PPU_read_1", "[PPU_read_1]") { Init() snes.bus->write(0x2115, 0b10000000); @@ -23,12 +23,12 @@ Test(PPU_read_1, vram_data_read_full) snes.bus->write(0x2116, 0); snes.bus->write(0x2117, 0); uint8_t tmp = snes.bus->read(0x2139); - cr_expect(tmp == 0b11111111, "Got %X expected 0xFF", tmp); + CHECK(tmp == 0b11111111); tmp = snes.bus->read(0x213a); - cr_expect(tmp == 0b11111111, "Got %X expected 0xFF", tmp); + CHECK(tmp == 0b11111111); } -Test(PPU_read_1, vram_data_read_half) +TEST_CASE("vram_data_read_half PPU_read_1", "[PPU_read_1]") { Init() snes.bus->write(0x2116, 0); @@ -39,7 +39,7 @@ Test(PPU_read_1, vram_data_read_half) snes.bus->write(0x2116, 0); snes.bus->write(0x2117, 0); uint8_t tmp = snes.bus->read(0x2139); - cr_expect(tmp == 0b01101001, "Got %X expected 0x69", tmp); + CHECK(tmp == 0b01101001); tmp = snes.bus->read(0x213a); - cr_expect(tmp == 0b11111111, "Got %X expected 0xFF", tmp); + CHECK(tmp == 0b11111111); } \ No newline at end of file diff --git a/tests/PPU/testPpuWrite.cpp b/tests/PPU/testPpuWrite.cpp index 3e63c36..902b657 100644 --- a/tests/PPU/testPpuWrite.cpp +++ b/tests/PPU/testPpuWrite.cpp @@ -2,7 +2,7 @@ // Created by cbihan on 2/10/20. // -#include +#include #include #include #include "../tests.hpp" @@ -11,255 +11,255 @@ #include "../../sources/PPU/PPU.hpp" using namespace ComSquare; -Test(PPU_write, inidisp_data_full_ones) +TEST_CASE("inidisp_data_full_ones PPU_write", "[PPU_write]") { Init() snes.bus->write(0x2100, 0b11111111); - cr_assert_eq(snes.ppu->_registers._inidisp.fblank, true); - cr_assert_eq(snes.ppu->_registers._inidisp.brightness, 0xF); + REQUIRE(snes.ppu->_registers._inidisp.fblank == true); + REQUIRE(snes.ppu->_registers._inidisp.brightness == 0xF); } -Test(PPU_write, inidisp_data_full_zeros) +TEST_CASE("inidisp_data_full_zeros PPU_write", "[PPU_write]") { Init() snes.bus->write(0x2100, 0b00000000); - cr_assert_eq(snes.ppu->_registers._inidisp.fblank, false); - cr_assert_eq(snes.ppu->_registers._inidisp.brightness, 0x0); + REQUIRE(snes.ppu->_registers._inidisp.fblank == false); + REQUIRE(snes.ppu->_registers._inidisp.brightness == 0x0); } -Test(PPU_write, inidisp_data_fBlank_on_brghtness_off) +TEST_CASE("inidisp_data_fBlank_on_brghtness_off PPU_write", "[PPU_write]") { Init() snes.bus->write(0x2100, 0b10000000); - cr_assert_eq(snes.ppu->_registers._inidisp.fblank, true); - cr_assert_eq(snes.ppu->_registers._inidisp.brightness, 0x0); + REQUIRE(snes.ppu->_registers._inidisp.fblank == true); + REQUIRE(snes.ppu->_registers._inidisp.brightness == 0x0); } -Test(PPU_write, inidisp_data_fBlank_off_brghtness_max) +TEST_CASE("inidisp_data_fBlank_off_brghtness_max PPU_write", "[PPU_write]") { Init() snes.bus->write(0x2100, 0b00001111); - cr_assert_eq(snes.ppu->_registers._inidisp.fblank, false); - cr_assert_eq(snes.ppu->_registers._inidisp.brightness, 0xF); + REQUIRE(snes.ppu->_registers._inidisp.fblank == false); + REQUIRE(snes.ppu->_registers._inidisp.brightness == 0xF); } -Test(PPU_write, inidisp_data_fBlank_off_brghtness_half) +TEST_CASE("inidisp_data_fBlank_off_brghtness_half PPU_write", "[PPU_write]") { Init() snes.bus->write(0x2100, 0b00000101); - cr_assert_eq(snes.ppu->_registers._inidisp.fblank, false); - cr_assert_eq(snes.ppu->_registers._inidisp.brightness, 0x5); + REQUIRE(snes.ppu->_registers._inidisp.fblank == false); + REQUIRE(snes.ppu->_registers._inidisp.brightness == 0x5); } -Test(PPU_write, obsel_111_object_size_and_all_null) +TEST_CASE("obsel_111_object_size_and_all_null PPU_write", "[PPU_write]") { Init() snes.bus->write(0x2101, 0b11100000); - cr_assert_eq(snes.ppu->_registers._obsel.objectSize, 0b111); - cr_assert_eq(snes.ppu->_registers._obsel.nameSelect, 0b00); - cr_assert_eq(snes.ppu->_registers._obsel.nameBaseSelect, 0b000); + REQUIRE(snes.ppu->_registers._obsel.objectSize == 0b111); + REQUIRE(snes.ppu->_registers._obsel.nameSelect == 0b00); + REQUIRE(snes.ppu->_registers._obsel.nameBaseSelect == 0b000); } -Test(PPU_write, obsel_data_full) +TEST_CASE("obsel_data_full PPU_write", "[PPU_write]") { Init() snes.bus->write(0x2101, 0b11111111); - cr_assert_eq(snes.ppu->_registers._obsel.objectSize, 0b111); - cr_assert_eq(snes.ppu->_registers._obsel.nameSelect, 0b11); - cr_assert_eq(snes.ppu->_registers._obsel.nameBaseSelect, 0b111); + REQUIRE(snes.ppu->_registers._obsel.objectSize == 0b111); + REQUIRE(snes.ppu->_registers._obsel.nameSelect == 0b11); + REQUIRE(snes.ppu->_registers._obsel.nameBaseSelect == 0b111); } -Test(PPU_write, obsel_data_full_nameselect) +TEST_CASE("obsel_data_full_nameselect PPU_write", "[PPU_write]") { Init() snes.bus->write(0x2101, 0b00011000); - cr_assert_eq(snes.ppu->_registers._obsel.objectSize, 0b000); - cr_assert_eq(snes.ppu->_registers._obsel.nameSelect, 0b11); - cr_assert_eq(snes.ppu->_registers._obsel.nameBaseSelect, 0b000); + REQUIRE(snes.ppu->_registers._obsel.objectSize == 0b000); + REQUIRE(snes.ppu->_registers._obsel.nameSelect == 0b11); + REQUIRE(snes.ppu->_registers._obsel.nameBaseSelect == 0b000); } -Test(PPU_write, obsel_data_full_baseselect) +TEST_CASE("obsel_data_full_baseselect_write", "[PPU_write]") { Init() snes.bus->write(0x2101, 0b00000111); - cr_assert_eq(snes.ppu->_registers._obsel.objectSize, 0b000); - cr_assert_eq(snes.ppu->_registers._obsel.nameSelect, 0b00); - cr_assert_eq(snes.ppu->_registers._obsel.nameBaseSelect, 0b111); + REQUIRE(snes.ppu->_registers._obsel.objectSize == 0b000); + REQUIRE(snes.ppu->_registers._obsel.nameSelect == 0b00); + REQUIRE(snes.ppu->_registers._obsel.nameBaseSelect == 0b111); } -Test(PPU_write, oamaddl_data_full) +TEST_CASE("oamaddl_data_full PPU_write", "[PPU_write]") { Init() snes.bus->write(0x2102, 0b11111111); - cr_assert_eq(snes.ppu->_registers._oamadd.oamAddress, 0b011111111); + REQUIRE(snes.ppu->_registers._oamadd.oamAddress == 0b011111111); } -Test(PPU_write, oamaddh_data_full) +TEST_CASE("oamaddh_data_full PPU_write", "[PPU_write]") { Init() snes.bus->write(0x2103, 0b11111111); - cr_assert_eq(snes.ppu->_registers._oamadd.objPriorityActivationBit, true); - cr_assert_eq(snes.ppu->_registers._oamadd.oamAddress, 0b100000000); + REQUIRE(snes.ppu->_registers._oamadd.objPriorityActivationBit == true); + REQUIRE(snes.ppu->_registers._oamadd.oamAddress == 0b100000000); } -Test(PPU_write, oamaddlh_data_full) +TEST_CASE("oamaddlh_data_full PPU_write", "[PPU_write]") { Init() snes.bus->write(0x2102, 0b11111111); snes.bus->write(0x2103, 0b11111111); - cr_assert_eq(snes.ppu->_registers._oamadd.objPriorityActivationBit, true); - cr_assert_eq(snes.ppu->_registers._oamadd.oamAddress, 0b111111111); + REQUIRE(snes.ppu->_registers._oamadd.objPriorityActivationBit == true); + REQUIRE(snes.ppu->_registers._oamadd.oamAddress == 0b111111111); } -Test(PPU_write, oamaddlh_data_full_priorityBit_off) +TEST_CASE("oamaddlh_data_full_priorityBit_off PPU_write", "[PPU_write]") { Init() snes.bus->write(0x2102, 0b11111111); snes.bus->write(0x2103, 0b01111111); - cr_assert_eq(snes.ppu->_registers._oamadd.objPriorityActivationBit, false); - cr_assert_eq(snes.ppu->_registers._oamadd.oamAddress, 0b111111111); + REQUIRE(snes.ppu->_registers._oamadd.objPriorityActivationBit == false); + REQUIRE(snes.ppu->_registers._oamadd.oamAddress == 0b111111111); } -Test(PPU_write, oamaddlh_oamAdress_11_priorityBit_on) +TEST_CASE("oamaddlh_oamAdress_11_priorityBit_on PPU_write", "[PPU_write]") { Init() snes.bus->write(0x2102, 0b00001011); snes.bus->write(0x2103, 0b10011100); - cr_assert_eq(snes.ppu->_registers._oamadd.objPriorityActivationBit, true); - cr_assert_eq(snes.ppu->_registers._oamadd.oamAddress, 11); + REQUIRE(snes.ppu->_registers._oamadd.objPriorityActivationBit == true); + REQUIRE(snes.ppu->_registers._oamadd.oamAddress == 11); } -Test(PPU_write, bgmode_data_full) +TEST_CASE("bgmode_data_full PPU_write", "[PPU_write]") { Init() snes.bus->write(0x2105, 0b11111111); - cr_assert_eq(snes.ppu->_registers._bgmode.bgMode, 7); - cr_assert_eq(snes.ppu->_registers._bgmode.characterSizeBg1, true); - cr_assert_eq(snes.ppu->_registers._bgmode.characterSizeBg2, true); - cr_assert_eq(snes.ppu->_registers._bgmode.characterSizeBg3, true); - cr_assert_eq(snes.ppu->_registers._bgmode.characterSizeBg4, true); - cr_assert_eq(snes.ppu->_registers._bgmode.mode1Bg3PriorityBit, true); + REQUIRE(snes.ppu->_registers._bgmode.bgMode == 7); + REQUIRE(snes.ppu->_registers._bgmode.characterSizeBg1 == true); + REQUIRE(snes.ppu->_registers._bgmode.characterSizeBg2 == true); + REQUIRE(snes.ppu->_registers._bgmode.characterSizeBg3 == true); + REQUIRE(snes.ppu->_registers._bgmode.characterSizeBg4 == true); + REQUIRE(snes.ppu->_registers._bgmode.mode1Bg3PriorityBit == true); } -Test(PPU_write, bgmode_bgmode_5_and_bg24_on) +TEST_CASE("bgmode_bgmode_5_and_bg24_on PPU_write", "[PPU_write]") { Init() snes.bus->write(0x2105, 0b10100101); - cr_assert_eq(snes.ppu->_registers._bgmode.bgMode, 5); - cr_assert_eq(snes.ppu->_registers._bgmode.characterSizeBg1, false); - cr_assert_eq(snes.ppu->_registers._bgmode.characterSizeBg2, true); - cr_assert_eq(snes.ppu->_registers._bgmode.characterSizeBg3, false); - cr_assert_eq(snes.ppu->_registers._bgmode.characterSizeBg4, true); - cr_assert_eq(snes.ppu->_registers._bgmode.mode1Bg3PriorityBit, false); + REQUIRE(snes.ppu->_registers._bgmode.bgMode == 5); + REQUIRE(snes.ppu->_registers._bgmode.characterSizeBg1 == false); + REQUIRE(snes.ppu->_registers._bgmode.characterSizeBg2 == true); + REQUIRE(snes.ppu->_registers._bgmode.characterSizeBg3 == false); + REQUIRE(snes.ppu->_registers._bgmode.characterSizeBg4 == true); + REQUIRE(snes.ppu->_registers._bgmode.mode1Bg3PriorityBit == false); } -Test(PPU_write, mosaic_data_full) +TEST_CASE("mosaic_data_full PPU_write", "[PPU_write]") { Init() snes.bus->write(0x2106, 0b11111111); - cr_assert_eq(snes.ppu->_registers._mosaic.affectBg1, true); - cr_assert_eq(snes.ppu->_registers._mosaic.affectBg2, true); - cr_assert_eq(snes.ppu->_registers._mosaic.affectBg3, true); - cr_assert_eq(snes.ppu->_registers._mosaic.affectBg4, true); - cr_assert_eq(snes.ppu->_registers._mosaic.pixelSize, 0xF); + REQUIRE(snes.ppu->_registers._mosaic.affectBg1 == true); + REQUIRE(snes.ppu->_registers._mosaic.affectBg2 == true); + REQUIRE(snes.ppu->_registers._mosaic.affectBg3 == true); + REQUIRE(snes.ppu->_registers._mosaic.affectBg4 == true); + REQUIRE(snes.ppu->_registers._mosaic.pixelSize == 0xF); } -Test(PPU_write, mosaic_affectbg23_w_1x1_size) +TEST_CASE("mosaic_affectbg23_w_1x1_size PPU_write", "[PPU_write]") { Init() snes.bus->write(0x2106, 0b00000110); - cr_assert_eq(snes.ppu->_registers._mosaic.affectBg1, false); - cr_assert_eq(snes.ppu->_registers._mosaic.affectBg2, true); - cr_assert_eq(snes.ppu->_registers._mosaic.affectBg3, true); - cr_assert_eq(snes.ppu->_registers._mosaic.affectBg4, false); - cr_assert_eq(snes.ppu->_registers._mosaic.pixelSize, 0x0); + REQUIRE(snes.ppu->_registers._mosaic.affectBg1 == false); + REQUIRE(snes.ppu->_registers._mosaic.affectBg2 == true); + REQUIRE(snes.ppu->_registers._mosaic.affectBg3 == true); + REQUIRE(snes.ppu->_registers._mosaic.affectBg4 == false); + REQUIRE(snes.ppu->_registers._mosaic.pixelSize == 0x0); } -Test(PPU_write, mosaic_affectbg14_w_2x2_size) +TEST_CASE("mosaic_affectbg14_w_2x2_size PPU_write", "[PPU_write]") { Init() snes.bus->write(0x2106, 0b00101001); - cr_assert_eq(snes.ppu->_registers._mosaic.affectBg1, true); - cr_assert_eq(snes.ppu->_registers._mosaic.affectBg2, false); - cr_assert_eq(snes.ppu->_registers._mosaic.affectBg3, false); - cr_assert_eq(snes.ppu->_registers._mosaic.affectBg4, true); - cr_assert_eq(snes.ppu->_registers._mosaic.pixelSize, 0x2); + REQUIRE(snes.ppu->_registers._mosaic.affectBg1 == true); + REQUIRE(snes.ppu->_registers._mosaic.affectBg2 == false); + REQUIRE(snes.ppu->_registers._mosaic.affectBg3 == false); + REQUIRE(snes.ppu->_registers._mosaic.affectBg4 == true); + REQUIRE(snes.ppu->_registers._mosaic.pixelSize == 0x2); } -Test(PPU_write, bg1sc_data_full) +TEST_CASE("bg1sc_data_full PPU_write", "[PPU_write]") { Init() snes.bus->write(0x2107, 0b11111111); - cr_assert_eq(snes.ppu->_registers._bgsc[0].tilemapAddress, 0b111111); - cr_assert_eq(snes.ppu->_registers._bgsc[0].tilemapHorizontalMirroring, true); - cr_assert_eq(snes.ppu->_registers._bgsc[0].tilemapVerticalMirroring, true); + REQUIRE(snes.ppu->_registers._bgsc[0].tilemapAddress == 0b111111); + REQUIRE(snes.ppu->_registers._bgsc[0].tilemapHorizontalMirroring == true); + REQUIRE(snes.ppu->_registers._bgsc[0].tilemapVerticalMirroring == true); } -Test(PPU_write, bg2sc_data_full) +TEST_CASE("bg2sc_data_full PPU_write", "[PPU_write]") { Init() snes.bus->write(0x2108, 0b11111111); - cr_assert_eq(snes.ppu->_registers._bgsc[1].tilemapAddress, 0b111111); - cr_assert_eq(snes.ppu->_registers._bgsc[1].tilemapHorizontalMirroring, true); - cr_assert_eq(snes.ppu->_registers._bgsc[1].tilemapVerticalMirroring, true); + REQUIRE(snes.ppu->_registers._bgsc[1].tilemapAddress == 0b111111); + REQUIRE(snes.ppu->_registers._bgsc[1].tilemapHorizontalMirroring == true); + REQUIRE(snes.ppu->_registers._bgsc[1].tilemapVerticalMirroring == true); } -Test(PPU_write, bg3sc_data_full) +TEST_CASE("bg3sc_data_full PPU_write", "[PPU_write]") { Init() snes.bus->write(0x2109, 0b11111111); - cr_assert_eq(snes.ppu->_registers._bgsc[2].tilemapAddress, 0b111111); - cr_assert_eq(snes.ppu->_registers._bgsc[2].tilemapHorizontalMirroring, true); - cr_assert_eq(snes.ppu->_registers._bgsc[2].tilemapVerticalMirroring, true); + REQUIRE(snes.ppu->_registers._bgsc[2].tilemapAddress == 0b111111); + REQUIRE(snes.ppu->_registers._bgsc[2].tilemapHorizontalMirroring == true); + REQUIRE(snes.ppu->_registers._bgsc[2].tilemapVerticalMirroring == true); } -Test(PPU_write, bg4sc_data_full) +TEST_CASE("bg4sc_data_full PPU_write", "[PPU_write]") { Init() snes.bus->write(0x210A, 0b11111111); - cr_assert_eq(snes.ppu->_registers._bgsc[3].tilemapAddress, 0b111111); - cr_assert_eq(snes.ppu->_registers._bgsc[3].tilemapHorizontalMirroring, true); - cr_assert_eq(snes.ppu->_registers._bgsc[3].tilemapVerticalMirroring, true); + REQUIRE(snes.ppu->_registers._bgsc[3].tilemapAddress == 0b111111); + REQUIRE(snes.ppu->_registers._bgsc[3].tilemapHorizontalMirroring == true); + REQUIRE(snes.ppu->_registers._bgsc[3].tilemapVerticalMirroring == true); } -Test(PPU_write, bg4sc_data_null) +TEST_CASE("bg4sc_data_null PPU_write", "[PPU_write]") { Init() snes.bus->write(0x210A, 0b00000000); - cr_assert_eq(snes.ppu->_registers._bgsc[3].tilemapAddress, 0); - cr_assert_eq(snes.ppu->_registers._bgsc[3].tilemapHorizontalMirroring, false); - cr_assert_eq(snes.ppu->_registers._bgsc[3].tilemapVerticalMirroring, false); + REQUIRE(snes.ppu->_registers._bgsc[3].tilemapAddress == 0); + REQUIRE(snes.ppu->_registers._bgsc[3].tilemapHorizontalMirroring == false); + REQUIRE(snes.ppu->_registers._bgsc[3].tilemapVerticalMirroring == false); } -Test(PPU_write, bg4sc_horizontal_off_vertical_on_random_tilemapAdress) +TEST_CASE("bg4sc_horizontal_off_vertical_on_random_tilemapAdress PPU_write", "[PPU_write]") { Init() snes.bus->write(0x210A, 0b11000110); - cr_assert_eq(snes.ppu->_registers._bgsc[3].tilemapAddress, 0b110001); - cr_assert_eq(snes.ppu->_registers._bgsc[3].tilemapHorizontalMirroring, false); - cr_assert_eq(snes.ppu->_registers._bgsc[3].tilemapVerticalMirroring, true); + REQUIRE(snes.ppu->_registers._bgsc[3].tilemapAddress == 0b110001); + REQUIRE(snes.ppu->_registers._bgsc[3].tilemapHorizontalMirroring == false); + REQUIRE(snes.ppu->_registers._bgsc[3].tilemapVerticalMirroring == true); } -Test(PPU_write, bg12nba_data_full) +TEST_CASE("bg12nba_data_full PPU_write", "[PPU_write]") { Init() snes.bus->write(0x210B, 0b11111111); - cr_assert_eq(snes.ppu->_registers._bgnba[0].baseAddressBg1a3, 0b1111); - cr_assert_eq(snes.ppu->_registers._bgnba[0].baseAddressBg2a4, 0b1111); + REQUIRE(snes.ppu->_registers._bgnba[0].baseAddressBg1a3 == 0b1111); + REQUIRE(snes.ppu->_registers._bgnba[0].baseAddressBg2a4 == 0b1111); } -Test(PPU_write, bg34nba_data_full) +TEST_CASE("bg34nba_data_full PPU_write", "[PPU_write]") { Init() snes.bus->write(0x210C, 0b11111111); - cr_assert_eq(snes.ppu->_registers._bgnba[1].baseAddressBg1a3, 0b1111); - cr_assert_eq(snes.ppu->_registers._bgnba[1].baseAddressBg2a4, 0b1111); + REQUIRE(snes.ppu->_registers._bgnba[1].baseAddressBg1a3 == 0b1111); + REQUIRE(snes.ppu->_registers._bgnba[1].baseAddressBg2a4 == 0b1111); } -Test(PPU_write, bg12nba_data_random_data) +TEST_CASE("bg12nba_data_random_data PPU_write", "[PPU_write]") { Init() snes.bus->write(0x210B, 0b10101010); - cr_assert_eq(snes.ppu->_registers._bgnba[0].baseAddressBg1a3, 0b1010); - cr_assert_eq(snes.ppu->_registers._bgnba[0].baseAddressBg2a4, 0b1010); + REQUIRE(snes.ppu->_registers._bgnba[0].baseAddressBg1a3 == 0b1010); + REQUIRE(snes.ppu->_registers._bgnba[0].baseAddressBg2a4 == 0b1010); } \ No newline at end of file diff --git a/tests/PPU/testPpuWriteFromVmain.cpp b/tests/PPU/testPpuWriteFromVmain.cpp index 92fe56a..438f57b 100644 --- a/tests/PPU/testPpuWriteFromVmain.cpp +++ b/tests/PPU/testPpuWriteFromVmain.cpp @@ -2,7 +2,7 @@ // Created by cbihan on 2/11/20. // -#include +#include #include #include #include "../tests.hpp" @@ -11,51 +11,51 @@ #include "../../sources/PPU/PPU.hpp" using namespace ComSquare; -Test(PPU_write_2, vmain_data_full) +TEST_CASE("vmain_data_full PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x2115, 0b11111111); - cr_assert_eq(snes.ppu->_registers._vmain.incrementMode, true); - cr_assert_eq(snes.ppu->_registers._vmain.addressRemapping, 0b11); - cr_assert_eq(snes.ppu->_registers._vmain.incrementAmount, 0b11); + REQUIRE(snes.ppu->_registers._vmain.incrementMode == true); + REQUIRE(snes.ppu->_registers._vmain.addressRemapping == 0b11); + REQUIRE(snes.ppu->_registers._vmain.incrementAmount == 0b11); } -Test(PPU_write_2, vmain_incrementmode_off_false_else_full) +TEST_CASE("vmain_incrementmode_off_false_else_full PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x2115, 0b01111111); - cr_assert_eq(snes.ppu->_registers._vmain.incrementMode, false); - cr_assert_eq(snes.ppu->_registers._vmain.addressRemapping, 0b11); - cr_assert_eq(snes.ppu->_registers._vmain.incrementAmount, 0b11); + REQUIRE(snes.ppu->_registers._vmain.incrementMode == false); + REQUIRE(snes.ppu->_registers._vmain.addressRemapping == 0b11); + REQUIRE(snes.ppu->_registers._vmain.incrementAmount == 0b11); } -Test(PPU_write_2, vmain_addressremaping_null_else_full) +TEST_CASE("vmain_addressremaping_null_else_full PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x2115, 0b11110011); - cr_assert_eq(snes.ppu->_registers._vmain.incrementMode, true); - cr_assert_eq(snes.ppu->_registers._vmain.addressRemapping, 0b00); - cr_assert_eq(snes.ppu->_registers._vmain.incrementAmount, 0b11); + REQUIRE(snes.ppu->_registers._vmain.incrementMode == true); + REQUIRE(snes.ppu->_registers._vmain.addressRemapping == 0b00); + REQUIRE(snes.ppu->_registers._vmain.incrementAmount == 0b11); } -Test(PPU_write_2, vmain_incrementamount_null_else_full) +TEST_CASE("vmain_incrementamount_null_else_full PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x2115, 0b11111100); - cr_assert_eq(snes.ppu->_registers._vmain.incrementMode, true); - cr_assert_eq(snes.ppu->_registers._vmain.addressRemapping, 0b11); - cr_assert_eq(snes.ppu->_registers._vmain.incrementAmount, 0b00); + REQUIRE(snes.ppu->_registers._vmain.incrementMode == true); + REQUIRE(snes.ppu->_registers._vmain.addressRemapping == 0b11); + REQUIRE(snes.ppu->_registers._vmain.incrementAmount == 0b00); } -Test(PPU_write_2, vmadd_full_data) +TEST_CASE("vmadd_full_data PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x2116, 0b11111111); snes.bus->write(0x2117, 0b11111111); - cr_assert_eq(snes.ppu->_registers._vmadd.vmadd, 0b1111111111111111); + REQUIRE(snes.ppu->_registers._vmadd.vmadd == 0b1111111111111111); } -Test(PPU_write_2, vmadd_full_data_check_ram) +TEST_CASE("vmadd_full_data_check_ram PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x2115, 0b10000000); @@ -63,238 +63,238 @@ Test(PPU_write_2, vmadd_full_data_check_ram) snes.bus->write(0x2117, 0); snes.bus->write(0x2118, 0xFF); snes.bus->write(0x2119, 0xFF); - cr_assert(snes.ppu->_registers._vmadd.vmadd == 3, "Got %d but expected 3", snes.ppu->_registers._vmadd.vmadd); - cr_assert(snes.ppu->vram->read(4) == 0xFF, "Got %X but expected 0xFF", snes.ppu->vram->read(4)); - cr_assert(snes.ppu->vram->read(5) == 0xFF, "Got %X but expected 0xFF", snes.ppu->vram->read(5)); + REQUIRE(snes.ppu->_registers._vmadd.vmadd == 3); + REQUIRE(snes.ppu->vram->read(4) == 0xFF); + REQUIRE(snes.ppu->vram->read(5) == 0xF); } -Test(PPU_write_2, vmadd_full_high_byte_null) +TEST_CASE("vmadd_full_high_byte_null PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x2116, 0b11111111); snes.bus->write(0x2117, 0b00000000); - cr_assert_eq(snes.ppu->_registers._vmadd.vmadd, 0b0000000011111111); + REQUIRE(snes.ppu->_registers._vmadd.vmadd == 0b0000000011111111); } -Test(PPU_write_2, vmdata_full_data) +TEST_CASE("vmdata_full_data PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x2118, 0b11111111); snes.bus->write(0x2119, 0b11111111); - cr_assert_eq(snes.ppu->_registers._vmdata.vmdata, 0b1111111111111111); + REQUIRE(snes.ppu->_registers._vmdata.vmdata == 0b1111111111111111); } -Test(PPU_write_2, vmdata_full_high_byte_null) +TEST_CASE("vmdata_full_high_byte_null PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x2118, 0b11111111); snes.bus->write(0x2119, 0b00000000); - cr_assert_eq(snes.ppu->_registers._vmdata.vmdata, 0b0000000011111111); + REQUIRE(snes.ppu->_registers._vmdata.vmdata == 0b0000000011111111); } -Test(PPU_write_2, cgadd_full_high_byte_null) +TEST_CASE("cgadd_full_high_byte_null PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x2121, 0b11111111); - cr_assert_eq(snes.ppu->_registers._cgadd, 0b11111111); - cr_assert_eq(snes.ppu->_registers._isLowByte, true); + REQUIRE(snes.ppu->_registers._cgadd == 0b11111111); + REQUIRE(snes.ppu->_registers._isLowByte == true); } -Test(PPU_write_2, cgdata_data_full) +TEST_CASE("cgdata_data_full PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x2121, 0x0); snes.bus->write(0x2122, 0b11111111); - cr_assert_eq(snes.ppu->_registers._cgdata.cgdatal, 0b11111111); - cr_assert_eq(snes.ppu->_registers._isLowByte, false); + REQUIRE(snes.ppu->_registers._cgdata.cgdatal == 0b11111111); + REQUIRE(snes.ppu->_registers._isLowByte == false); int address = snes.ppu->_registers._cgadd; snes.bus->write(0x2122, 0b11111000); - cr_assert_eq(snes.ppu->_registers._cgdata.cgdatah, 0b11111000); - cr_assert_eq(snes.ppu->_registers._isLowByte, true); - cr_assert_eq(snes.ppu->_registers._cgadd, address + 2); + REQUIRE(snes.ppu->_registers._cgdata.cgdatah == 0b11111000); + REQUIRE(snes.ppu->_registers._isLowByte == true); + REQUIRE(snes.ppu->_registers._cgadd == address + 2); } -Test(PPU_write_2, m7sel_data_full) +TEST_CASE("m7sel_data_full PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x211A, 0b11111111); - cr_assert_eq(snes.ppu->_registers._m7sel.playingFieldSize, true); - cr_assert_eq(snes.ppu->_registers._m7sel.emptySpaceFill, true); - cr_assert_eq(snes.ppu->_registers._m7sel.horizontalMirroring, true); - cr_assert_eq(snes.ppu->_registers._m7sel.verticalMirroring, true); + REQUIRE(snes.ppu->_registers._m7sel.playingFieldSize == true); + REQUIRE(snes.ppu->_registers._m7sel.emptySpaceFill == true); + REQUIRE(snes.ppu->_registers._m7sel.horizontalMirroring == true); + REQUIRE(snes.ppu->_registers._m7sel.verticalMirroring == true); } -Test(PPU_write_2, m7sel_data_actual) +TEST_CASE("m7sel_data_actual PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x211A, 0b01111101); - cr_assert_eq(snes.ppu->_registers._m7sel.playingFieldSize, false); - cr_assert_eq(snes.ppu->_registers._m7sel.emptySpaceFill, true); - cr_assert_eq(snes.ppu->_registers._m7sel.horizontalMirroring, true); - cr_assert_eq(snes.ppu->_registers._m7sel.verticalMirroring, false); + REQUIRE(snes.ppu->_registers._m7sel.playingFieldSize == false); + REQUIRE(snes.ppu->_registers._m7sel.emptySpaceFill == true); + REQUIRE(snes.ppu->_registers._m7sel.horizontalMirroring == true); + REQUIRE(snes.ppu->_registers._m7sel.verticalMirroring == false); } -Test(PPU_write_2, w12sel_data_full) +TEST_CASE("w12sel_data_full PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x2123, 0b11111111); - cr_assert_eq(snes.ppu->_registers._wsel[0].window1InversionForBg1Bg3Obj, true); - cr_assert_eq(snes.ppu->_registers._wsel[0].enableWindow1ForBg1Bg3Obj, true); - cr_assert_eq(snes.ppu->_registers._wsel[0].window2InversionForBg1Bg3Obj, true); - cr_assert_eq(snes.ppu->_registers._wsel[0].enableWindow2ForBg1Bg3Obj, true); - cr_assert_eq(snes.ppu->_registers._wsel[0].window1InversionForBg2Bg4Color, true); - cr_assert_eq(snes.ppu->_registers._wsel[0].enableWindow1ForBg2Bg4Color, true); - cr_assert_eq(snes.ppu->_registers._wsel[0].window2InversionForBg2Bg4Color, true); - cr_assert_eq(snes.ppu->_registers._wsel[0].enableWindow2ForBg2Bg4Color, true); + REQUIRE(snes.ppu->_registers._wsel[0].window1InversionForBg1Bg3Obj == true); + REQUIRE(snes.ppu->_registers._wsel[0].enableWindow1ForBg1Bg3Obj == true); + REQUIRE(snes.ppu->_registers._wsel[0].window2InversionForBg1Bg3Obj == true); + REQUIRE(snes.ppu->_registers._wsel[0].enableWindow2ForBg1Bg3Obj == true); + REQUIRE(snes.ppu->_registers._wsel[0].window1InversionForBg2Bg4Color == true); + REQUIRE(snes.ppu->_registers._wsel[0].enableWindow1ForBg2Bg4Color == true); + REQUIRE(snes.ppu->_registers._wsel[0].window2InversionForBg2Bg4Color == true); + REQUIRE(snes.ppu->_registers._wsel[0].enableWindow2ForBg2Bg4Color == true); } -Test(PPU_write_2, w34sel_data_full) +TEST_CASE("w34sel_data_full PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x2124, 0b10101010); - cr_assert_eq(snes.ppu->_registers._wsel[1].window1InversionForBg1Bg3Obj, true); - cr_assert_eq(snes.ppu->_registers._wsel[1].enableWindow1ForBg1Bg3Obj, false); - cr_assert_eq(snes.ppu->_registers._wsel[1].window2InversionForBg1Bg3Obj, true); - cr_assert_eq(snes.ppu->_registers._wsel[1].enableWindow2ForBg1Bg3Obj, false); - cr_assert_eq(snes.ppu->_registers._wsel[1].window1InversionForBg2Bg4Color, true); - cr_assert_eq(snes.ppu->_registers._wsel[1].enableWindow1ForBg2Bg4Color, false); - cr_assert_eq(snes.ppu->_registers._wsel[1].window2InversionForBg2Bg4Color, true); - cr_assert_eq(snes.ppu->_registers._wsel[1].enableWindow2ForBg2Bg4Color, false); + REQUIRE(snes.ppu->_registers._wsel[1].window1InversionForBg1Bg3Obj == true); + REQUIRE(snes.ppu->_registers._wsel[1].enableWindow1ForBg1Bg3Obj == false); + REQUIRE(snes.ppu->_registers._wsel[1].window2InversionForBg1Bg3Obj == true); + REQUIRE(snes.ppu->_registers._wsel[1].enableWindow2ForBg1Bg3Obj == false); + REQUIRE(snes.ppu->_registers._wsel[1].window1InversionForBg2Bg4Color == true); + REQUIRE(snes.ppu->_registers._wsel[1].enableWindow1ForBg2Bg4Color == false); + REQUIRE(snes.ppu->_registers._wsel[1].window2InversionForBg2Bg4Color == true); + REQUIRE(snes.ppu->_registers._wsel[1].enableWindow2ForBg2Bg4Color == false); } -Test(PPU_write_2, wobjsel_data_full) +TEST_CASE("wobjsel_data_full PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x2125, 0b10110001); - cr_assert_eq(snes.ppu->_registers._wsel[2].window1InversionForBg1Bg3Obj, true); - cr_assert_eq(snes.ppu->_registers._wsel[2].enableWindow1ForBg1Bg3Obj, false); - cr_assert_eq(snes.ppu->_registers._wsel[2].window2InversionForBg1Bg3Obj, true); - cr_assert_eq(snes.ppu->_registers._wsel[2].enableWindow2ForBg1Bg3Obj, true); - cr_assert_eq(snes.ppu->_registers._wsel[2].window1InversionForBg2Bg4Color, false); - cr_assert_eq(snes.ppu->_registers._wsel[2].enableWindow1ForBg2Bg4Color, false); - cr_assert_eq(snes.ppu->_registers._wsel[2].window2InversionForBg2Bg4Color, false); - cr_assert_eq(snes.ppu->_registers._wsel[2].enableWindow2ForBg2Bg4Color, true); + REQUIRE(snes.ppu->_registers._wsel[2].window1InversionForBg1Bg3Obj == true); + REQUIRE(snes.ppu->_registers._wsel[2].enableWindow1ForBg1Bg3Obj == false); + REQUIRE(snes.ppu->_registers._wsel[2].window2InversionForBg1Bg3Obj == true); + REQUIRE(snes.ppu->_registers._wsel[2].enableWindow2ForBg1Bg3Obj == true); + REQUIRE(snes.ppu->_registers._wsel[2].window1InversionForBg2Bg4Color == false); + REQUIRE(snes.ppu->_registers._wsel[2].enableWindow1ForBg2Bg4Color == false); + REQUIRE(snes.ppu->_registers._wsel[2].window2InversionForBg2Bg4Color == false); + REQUIRE(snes.ppu->_registers._wsel[2].enableWindow2ForBg2Bg4Color == true); } -Test(PPU_write_2, wbglog_data_full) +TEST_CASE("wbglog_data_full PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x212A, 0b10110001); - cr_assert_eq(snes.ppu->_registers._wbglog.maskLogicBg1, 0b10); - cr_assert_eq(snes.ppu->_registers._wbglog.maskLogicBg2, 0b11); - cr_assert_eq(snes.ppu->_registers._wbglog.maskLogicBg3, 0b00); - cr_assert_eq(snes.ppu->_registers._wbglog.maskLogicBg4, 0b01); + REQUIRE(snes.ppu->_registers._wbglog.maskLogicBg1 == 0b10); + REQUIRE(snes.ppu->_registers._wbglog.maskLogicBg2 == 0b11); + REQUIRE(snes.ppu->_registers._wbglog.maskLogicBg3 == 0b00); + REQUIRE(snes.ppu->_registers._wbglog.maskLogicBg4 == 0b01); } -Test(PPU_write_2, wobjlog_data_full) +TEST_CASE("wobjlog_data_full PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x212B, 0b10110001); - cr_assert_eq(snes.ppu->_registers._wobjlog.maskLogicObj, 0b01); - cr_assert_eq(snes.ppu->_registers._wobjlog.maskLogicColor, 0b00); + REQUIRE(snes.ppu->_registers._wobjlog.maskLogicObj == 0b01); + REQUIRE(snes.ppu->_registers._wobjlog.maskLogicColor == 0b00); } -Test(PPU_write_2, tm_data_full) +TEST_CASE("tm_data_full PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x212C, 0b10110001); - cr_assert_eq(snes.ppu->_registers._t[0].enableWindowDisplayBg1, true); - cr_assert_eq(snes.ppu->_registers._t[0].enableWindowDisplayBg2, false); - cr_assert_eq(snes.ppu->_registers._t[0].enableWindowDisplayBg3, false); - cr_assert_eq(snes.ppu->_registers._t[0].enableWindowDisplayBg4, false); - cr_assert_eq(snes.ppu->_registers._t[0].enableWindowDisplayObj, true); + REQUIRE(snes.ppu->_registers._t[0].enableWindowDisplayBg1 == true); + REQUIRE(snes.ppu->_registers._t[0].enableWindowDisplayBg2 == false); + REQUIRE(snes.ppu->_registers._t[0].enableWindowDisplayBg3 == false); + REQUIRE(snes.ppu->_registers._t[0].enableWindowDisplayBg4 == false); + REQUIRE(snes.ppu->_registers._t[0].enableWindowDisplayObj == true); } -Test(PPU_write_2, ts_data_full) +TEST_CASE("ts_data_full PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x212D, 0b10101110); - cr_assert_eq(snes.ppu->_registers._t[1].enableWindowDisplayBg1, false); - cr_assert_eq(snes.ppu->_registers._t[1].enableWindowDisplayBg2, true); - cr_assert_eq(snes.ppu->_registers._t[1].enableWindowDisplayBg3, true); - cr_assert_eq(snes.ppu->_registers._t[1].enableWindowDisplayBg4, true); - cr_assert_eq(snes.ppu->_registers._t[1].enableWindowDisplayObj, false); + REQUIRE(snes.ppu->_registers._t[1].enableWindowDisplayBg1 == false); + REQUIRE(snes.ppu->_registers._t[1].enableWindowDisplayBg2 == true); + REQUIRE(snes.ppu->_registers._t[1].enableWindowDisplayBg3 == true); + REQUIRE(snes.ppu->_registers._t[1].enableWindowDisplayBg4 == true); + REQUIRE(snes.ppu->_registers._t[1].enableWindowDisplayObj == false); } -Test(PPU_write_2, tmw_data_full) +TEST_CASE("tmw_data_full PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x212E, 0b10101110); - cr_assert_eq(snes.ppu->_registers._tw[0].enableWindowMaskingBg1, false); - cr_assert_eq(snes.ppu->_registers._tw[0].enableWindowMaskingBg2, true); - cr_assert_eq(snes.ppu->_registers._tw[0].enableWindowMaskingBg3, true); - cr_assert_eq(snes.ppu->_registers._tw[0].enableWindowMaskingBg4, true); - cr_assert_eq(snes.ppu->_registers._tw[0].enableWindowMaskingObj, false); + REQUIRE(snes.ppu->_registers._tw[0].enableWindowMaskingBg1 == false); + REQUIRE(snes.ppu->_registers._tw[0].enableWindowMaskingBg2 == true); + REQUIRE(snes.ppu->_registers._tw[0].enableWindowMaskingBg3 == true); + REQUIRE(snes.ppu->_registers._tw[0].enableWindowMaskingBg4 == true); + REQUIRE(snes.ppu->_registers._tw[0].enableWindowMaskingObj == false); } -Test(PPU_write_2, tsw_data_full) +TEST_CASE("tsw_data_full PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x212F, 0b10100011); - cr_assert_eq(snes.ppu->_registers._tw[1].enableWindowMaskingBg1, true); - cr_assert_eq(snes.ppu->_registers._tw[1].enableWindowMaskingBg2, true); - cr_assert_eq(snes.ppu->_registers._tw[1].enableWindowMaskingBg3, false); - cr_assert_eq(snes.ppu->_registers._tw[1].enableWindowMaskingBg4, false); - cr_assert_eq(snes.ppu->_registers._tw[1].enableWindowMaskingObj, false); + REQUIRE(snes.ppu->_registers._tw[1].enableWindowMaskingBg1 == true); + REQUIRE(snes.ppu->_registers._tw[1].enableWindowMaskingBg2 == true); + REQUIRE(snes.ppu->_registers._tw[1].enableWindowMaskingBg3 == false); + REQUIRE(snes.ppu->_registers._tw[1].enableWindowMaskingBg4 == false); + REQUIRE(snes.ppu->_registers._tw[1].enableWindowMaskingObj == false); } -Test(PPU_write_2, cgwsel_data_full) +TEST_CASE("cgwsel_data_full PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x2130, 0b10111001); - cr_assert_eq(snes.ppu->_registers._cgwsel.clipColorToBlackBeforeMath, 0b10); - cr_assert_eq(snes.ppu->_registers._cgwsel.preventColorMath, 0b11); - cr_assert_eq(snes.ppu->_registers._cgwsel.addSubscreen, false); - cr_assert_eq(snes.ppu->_registers._cgwsel.directColorMode, true); + REQUIRE(snes.ppu->_registers._cgwsel.clipColorToBlackBeforeMath == 0b10); + REQUIRE(snes.ppu->_registers._cgwsel.preventColorMath == 0b11); + REQUIRE(snes.ppu->_registers._cgwsel.addSubscreen == false); + REQUIRE(snes.ppu->_registers._cgwsel.directColorMode == true); } -Test(PPU_write_2, cgadsub_data_full) +TEST_CASE("cgadsub_data_full PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x2131, 0b10111001); - cr_assert_eq(snes.ppu->_registers._cgadsub.addSubtractSelect, true); - cr_assert_eq(snes.ppu->_registers._cgadsub.halfColorMath, false); - cr_assert_eq(snes.ppu->_registers._cgadsub.enableColorMathBackdrop, true); - cr_assert_eq(snes.ppu->_registers._cgadsub.enableColorMathObj, true); - cr_assert_eq(snes.ppu->_registers._cgadsub.enableColorMathBg4, true); - cr_assert_eq(snes.ppu->_registers._cgadsub.enableColorMathBg3, false); - cr_assert_eq(snes.ppu->_registers._cgadsub.enableColorMathBg2, false); - cr_assert_eq(snes.ppu->_registers._cgadsub.enableColorMathBg1, true); + REQUIRE(snes.ppu->_registers._cgadsub.addSubtractSelect == true); + REQUIRE(snes.ppu->_registers._cgadsub.halfColorMath == false); + REQUIRE(snes.ppu->_registers._cgadsub.enableColorMathBackdrop == true); + REQUIRE(snes.ppu->_registers._cgadsub.enableColorMathObj == true); + REQUIRE(snes.ppu->_registers._cgadsub.enableColorMathBg4 == true); + REQUIRE(snes.ppu->_registers._cgadsub.enableColorMathBg3 == false); + REQUIRE(snes.ppu->_registers._cgadsub.enableColorMathBg2 == false); + REQUIRE(snes.ppu->_registers._cgadsub.enableColorMathBg1 == true); } -Test(PPU_write_2, coldata_data_full) +TEST_CASE("coldata_data_full PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x2132, 0b10111001); - cr_assert_eq(snes.ppu->_registers._coldata.blue, true); - cr_assert_eq(snes.ppu->_registers._coldata.green, false); - cr_assert_eq(snes.ppu->_registers._coldata.red, true); - cr_assert_eq(snes.ppu->_registers._coldata.colorIntensity, 0b11001); + REQUIRE(snes.ppu->_registers._coldata.blue == true); + REQUIRE(snes.ppu->_registers._coldata.green == false); + REQUIRE(snes.ppu->_registers._coldata.red == true); + REQUIRE(snes.ppu->_registers._coldata.colorIntensity == 0b11001); } -Test(PPU_write_2, setini_data_full) +TEST_CASE("setini_data_full PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x2133, 0b10111001); - cr_assert_eq(snes.ppu->_registers._setini.externalSync, true); - cr_assert_eq(snes.ppu->_registers._setini.mode7ExtBg, false); - cr_assert_eq(snes.ppu->_registers._setini.enablePseudoHiresMode, true); - cr_assert_eq(snes.ppu->_registers._setini.overscanMode, false); - cr_assert_eq(snes.ppu->_registers._setini.objInterlace, false); - cr_assert_eq(snes.ppu->_registers._setini.screenInterlace, true); + REQUIRE(snes.ppu->_registers._setini.externalSync == true); + REQUIRE(snes.ppu->_registers._setini.mode7ExtBg == false); + REQUIRE(snes.ppu->_registers._setini.enablePseudoHiresMode == true); + REQUIRE(snes.ppu->_registers._setini.overscanMode == false); + REQUIRE(snes.ppu->_registers._setini.objInterlace == false); + REQUIRE(snes.ppu->_registers._setini.screenInterlace == true); } -Test(PPU_write_2, m7a_data_full) +TEST_CASE("m7a_data_full PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x211B, 0b10111001); - cr_assert_eq(snes.ppu->_registers._m7[0].m7l, 0b10111001); + REQUIRE(snes.ppu->_registers._m7[0].m7l == 0b10111001); } -Test(PPU_write_2, m7c_data_low_and_high_byte) +TEST_CASE("m7c_data_low_and_high_byte PPU_write_2", "[PPU_write_2]") { Init() snes.bus->write(0x211D, 0b10111001); snes.bus->write(0x211D, 0b11111111); - cr_assert_eq(snes.ppu->_registers._m7[2].m7, 0b1011100111111111); + REQUIRE(snes.ppu->_registers._m7[2].m7 == 0b1011100111111111); } \ No newline at end of file diff --git a/tests/testMemoryBus.cpp b/tests/testMemoryBus.cpp index cb8c9dc..0e834d6 100644 --- a/tests/testMemoryBus.cpp +++ b/tests/testMemoryBus.cpp @@ -2,8 +2,7 @@ // Created by Melefo on 05/02/2020. // -#include -#include +#include #include #include "tests.hpp" #include "../sources/Memory/MemoryShadow.hpp" @@ -19,239 +18,245 @@ using namespace ComSquare; // // ////////////////////////////////// -Test(BusAccessor, GetWramStart) +TEST_CASE("GetWramStart BusAccessor", "[BusAccessor]") { Init() std::shared_ptr accessor; accessor = snes.bus->getAccessor(0x7E0000); - cr_assert_eq(accessor.get(), snes.wram.get()); + REQUIRE(accessor.get() == snes.wram.get()); } -Test(BusAccessor, GetWramEnd) +TEST_CASE("GetWramEnd BusAccessor", "[BusAccessor]") { Init() std::shared_ptr accessor; accessor = snes.bus->getAccessor(0x7FFFFF); - cr_assert_eq(accessor.get(), snes.wram.get()); + REQUIRE(accessor.get() == snes.wram.get()); } -Test(BusAccessor, GetWramMirror) +TEST_CASE("GetWramMirror BusAccessor", "[BusAccessor]") { Init() std::shared_ptr accessor; accessor = std::static_pointer_cast(snes.bus->getAccessor(0x2F11FF)); - cr_assert_neq(accessor, nullptr); - cr_assert_eq(accessor->_initial.get(), snes.wram.get()); + REQUIRE(accessor != nullptr); + REQUIRE(accessor->_initial.get() == snes.wram.get()); } -Test(BusAccessor, GetWramMirror2) +TEST_CASE("GetWramMirror2 BusAccessor", "[BusAccessor]") { Init() std::shared_ptr accessor; accessor = std::static_pointer_cast(snes.bus->getAccessor(0x100000)); - cr_assert_neq(accessor, nullptr); - cr_assert_eq(accessor->_initial.get(), snes.wram.get()); + REQUIRE(accessor != nullptr); + REQUIRE(accessor->_initial.get() == snes.wram.get()); } -Test(BusAccessor, GetWramMirror3) +TEST_CASE("GetWramMirror3 BusAccessor", "[BusAccessor]") { Init() std::shared_ptr accessor; accessor = std::static_pointer_cast(snes.bus->getAccessor(0x1010)); - cr_assert_neq(accessor, nullptr); - cr_assert_eq(accessor->_initial.get(), snes.wram.get()); + REQUIRE(accessor != nullptr); + REQUIRE(accessor->_initial.get() == snes.wram.get()); } -Test(BusAccessor, GetOpenBus) +TEST_CASE("GetOpenBus BusAccessor", "[BusAccessor]") { Init() std::shared_ptr accessor = snes.bus->getAccessor(0x897654); - cr_assert_eq(accessor.get(), nullptr); + REQUIRE(accessor.get() == nullptr); } -Test(BusAccessor, GetSramStart) +TEST_CASE("GetSramStart BusAccessor", "[BusAccessor]") { Init() std::shared_ptr accessor; accessor = std::static_pointer_cast(snes.bus->getAccessor(0x700000)); - cr_assert_eq(accessor->_initial.get(), snes.sram.get()); + REQUIRE(accessor); + REQUIRE(accessor->_initial.get() == snes.sram.get()); } -Test(BusAccessor, GetSramEnd) +TEST_CASE("GetSramEnd BusAccessor", "[BusAccessor]") { Init() std::shared_ptr accessor; accessor = std::static_pointer_cast(snes.bus->getAccessor(0x7D7FFF)); - cr_assert_eq(accessor->_initial.get(), snes.sram.get()); + REQUIRE(accessor); + REQUIRE(accessor->_initial.get() == snes.sram.get()); } -Test(BusAccessor, GetSramMirror) +TEST_CASE("GetSramMirror BusAccessor", "[BusAccessor]") { Init() std::shared_ptr accessor; accessor = std::static_pointer_cast(snes.bus->getAccessor(0xF00123)); - cr_assert_eq(accessor.get(), snes.sram.get()); + REQUIRE(accessor.get() == snes.sram.get()); } -Test(BusAccessor, GetAPUStart) +TEST_CASE("GetAPUStart BusAccessor", "[BusAccessor]") { Init() std::shared_ptr accessor; accessor = snes.bus->getAccessor(0x002140); - cr_assert_eq(accessor.get(), snes.apu.get()); + REQUIRE(accessor.get() == snes.apu.get()); } -Test(BusAccessor, GetAPUEnd) +TEST_CASE("GetAPUEnd BusAccessor", "[BusAccessor]") { Init() std::shared_ptr accessor; accessor = snes.bus->getAccessor(0x002143); - cr_assert_eq(accessor.get(), snes.apu.get()); + REQUIRE(accessor.get() == snes.apu.get()); } -Test(BusAccessor, GetAPUMirror) +TEST_CASE("GetAPUMirror BusAccessor", "[BusAccessor]") { Init() std::shared_ptr accessor; accessor = std::static_pointer_cast(snes.bus->getAccessor(0xAB2143)); - cr_assert_eq(accessor->_initial.get(), snes.apu.get()); + REQUIRE(accessor->_initial.get() == snes.apu.get()); } -Test(BusAccessor, GetAPUMirrorFirstHalf) +TEST_CASE("GetAPUMirrorFirstHalf BusAccessor", "[BusAccessor]") { Init() std::shared_ptr accessor; accessor = std::static_pointer_cast(snes.bus->getAccessor(0x052143)); - cr_assert_eq(accessor->_initial.get(), snes.apu.get()); + REQUIRE(accessor->_initial.get() == snes.apu.get()); } -Test(BusAccessor, GetCPUStart) +TEST_CASE("GetCPUStart BusAccessor", "[BusAccessor]") { Init() std::shared_ptr accessor; accessor = snes.bus->getAccessor(0x004200); - cr_assert_eq(accessor.get(), snes.cpu.get()); + REQUIRE(accessor.get() == snes.cpu.get()); } -Test(BusAccessor, GetCPUEnd) +TEST_CASE("GetCPUEnd BusAccessor", "[BusAccessor]") { Init() std::shared_ptr accessor; accessor = snes.bus->getAccessor(0x00421F); - cr_assert_eq(accessor.get(), snes.cpu.get()); + REQUIRE(accessor.get() == snes.cpu.get()); } -Test(BusAccessor, GetPPU1Start) +TEST_CASE("GetPPU1Start BusAccessor", "[BusAccessor]") { Init() std::shared_ptr accessor; accessor = snes.bus->getAccessor(0x00213E); - cr_assert_eq(accessor.get(), snes.ppu.get()); + REQUIRE(accessor.get() == snes.ppu.get()); } -Test(BusAccessor, GetPPU1End) +TEST_CASE("GetPPU1End BusAccessor", "[BusAccessor]") { Init() std::shared_ptr accessor; accessor = snes.bus->getAccessor(0x00213F); - cr_assert_eq(accessor.get(), snes.ppu.get()); + REQUIRE(accessor.get() == snes.ppu.get()); } -Test(BusAccessor, GetCPU) +TEST_CASE("GetCPU BusAccessor", "[BusAccessor]") { Init() std::shared_ptr accessor; accessor = snes.bus->getAccessor(0x004212); - cr_assert_eq(accessor.get(), snes.cpu.get()); + REQUIRE(accessor.get() == snes.cpu.get()); } -Test(BusAccessor, GetPPU1Mirror) +TEST_CASE("GetPPU1Mirror BusAccessor", "[BusAccessor]") { Init() std::shared_ptr accessor; accessor = std::static_pointer_cast(snes.bus->getAccessor(0x80213F)); - cr_assert_eq(accessor->_initial.get(), snes.ppu.get()); + REQUIRE(accessor->_initial.get() == snes.ppu.get()); } -Test(BusAccessor, GetCPU2Mirror) +TEST_CASE("GetCPU2Mirror BusAccessor", "[BusAccessor]") { Init() std::shared_ptr accessor; accessor = std::static_pointer_cast(snes.bus->getAccessor(0x804212)); - cr_assert_eq(accessor->_initial.get(), snes.cpu.get()); + REQUIRE(accessor->_initial.get() == snes.cpu.get()); } -Test(BusAccessor, GetRomStart) +TEST_CASE("GetRomStart BusAccessor", "[BusAccessor]") { Init() std::shared_ptr accessor; accessor = snes.bus->getAccessor(0x808000); - cr_assert_eq(accessor.get(), snes.cartridge.get()); + REQUIRE(accessor.get() == snes.cartridge.get()); } -Test(BusAccessor, GetRomEnd) +TEST_CASE("GetRomEnd BusAccessor", "[BusAccessor]") { Init() std::shared_ptr accessor; accessor = snes.bus->getAccessor(0xFFFFFF); - cr_assert_eq(accessor.get(), snes.cartridge.get()); + REQUIRE(accessor.get() == snes.cartridge.get()); } -Test(BusAccessor, GetRomMirror) +TEST_CASE("GetRomMirror BusAccessor", "[BusAccessor]") { Init() std::shared_ptr accessor; accessor = std::static_pointer_cast(snes.bus->getAccessor(0x694200)); - cr_assert_eq(accessor->_initial.get(), snes.cartridge.get()); + REQUIRE(accessor); + REQUIRE(accessor->_initial.get() == snes.cartridge.get()); } -Test(BusAccessor, GetRomMirror2) +TEST_CASE("GetRomMirror2 BusAccessor", "[BusAccessor]") { Init() std::shared_ptr accessor; accessor = std::static_pointer_cast(snes.bus->getAccessor(0x01FEDC)); - cr_assert_eq(accessor->_initial.get(), snes.cartridge.get()); + REQUIRE(accessor); + REQUIRE(accessor->_initial.get() == snes.cartridge.get()); } -Test(BusAccessor, GetRomMirror3) +TEST_CASE("GetRomMirror3 BusAccessor", "[BusAccessor]") { Init() std::shared_ptr accessor; accessor = std::static_pointer_cast(snes.bus->getAccessor(0xDE1248)); - cr_assert_eq(accessor->_initial.get(), snes.cartridge.get()); + REQUIRE(accessor); + REQUIRE(accessor->_initial.get() == snes.cartridge.get()); } -Test(BusAccessor, Get0x0) +TEST_CASE("Get0x0 BusAccessor", "[BusAccessor]") { Init() std::shared_ptr accessor; accessor = std::static_pointer_cast(snes.bus->getAccessor(0x0)); - cr_assert_eq(accessor->_initial.get(), snes.wram.get()); + REQUIRE(accessor); + REQUIRE(accessor->_initial.get() == snes.wram.get()); } /////////////////////////// @@ -260,135 +265,135 @@ Test(BusAccessor, Get0x0) // // /////////////////////////// -Test(BusRead, Read0x0) +TEST_CASE("Read0x0 BusRead", "[BusRead]") { Init() uint8_t data; snes.wram->_data[0] = 123; data = snes.bus->read(0x0); - cr_assert_eq(data, 123); + REQUIRE(data == 123); } -Test(BusRead, ReadOutside, .init = cr_redirect_stdout) +TEST_CASE("Read ReadOutside", "[ReadOutside]") { Init() uint8_t data; snes.bus->_openBus = 123; data = snes.bus->read(0x002000); - cr_assert_eq(data, 123); + REQUIRE(data == 123); } -Test(BusRead, ReadOutside2, .init = cr_redirect_stdout) +TEST_CASE("ReadOutside2 Read][Bus", "[Read][Bus]") { Init() uint8_t data; snes.bus->_openBus = 123; data = snes.bus->read(0xBF2FFF); - cr_assert_eq(data, 123); + REQUIRE(data == 123); } -Test(BusRead, ReadOutside3, .init = cr_redirect_stdout) +TEST_CASE("ReadOutside3 Read][Bus", "[Read][Bus]") { Init() uint8_t data; snes.bus->_openBus = 123; data = snes.bus->read(0x127654); - cr_assert_eq(data, 123); + REQUIRE(data == 123); } -Test(BusRead, ReadAPU) +TEST_CASE("ReadAPU BusRead", "[BusRead]") { Init() uint8_t data; snes.apu->_registers.port0 = 123; data = snes.bus->read(0x002140); - cr_assert_eq(data, 123); + REQUIRE(data == 123); } -Test(BusRead, ReadROM) +TEST_CASE("ReadROM BusRead", "[BusRead]") { Init() uint8_t data; snes.cartridge->_data[5] = 123; data = snes.bus->read(0x808005); - cr_assert_eq(data, 123); + REQUIRE(data == 123); } -Test(BusRead, ReadROMStart) +TEST_CASE("ReadROMStart BusRead", "[BusRead]") { Init() uint8_t data; snes.cartridge->_data[0] = 123; data = snes.bus->read(0x808000); - cr_assert_eq(data, 123); + REQUIRE(data == 123); } -Test(BusRead, ReadCPU) +TEST_CASE("ReadCPU BusRead", "[BusRead]") { Init() uint8_t data; snes.cpu->_internalRegisters.wrio = 123; data = snes.bus->read(0x004201); - cr_assert_eq(data, 123); + REQUIRE(data == 123); } -Test(BusRead, ReadPPU) +TEST_CASE("ReadPPU BusRead", "[BusRead]") { Init() uint8_t data; snes.ppu->_registers._mpy.mpyl = 123; data = snes.bus->read(0x002134); - cr_assert_eq(data, 123); + REQUIRE(data == 123); } -Test(BusRead, ReadSRAM) +TEST_CASE("ReadSRAM BusRead", "[BusRead]") { Init() uint8_t data; snes.sram->_data[7] = 123; data = snes.bus->read(0x700007); - cr_assert_eq(data, 123); + REQUIRE(data == 123); } -Test(BusRead, ReadWRAM) +TEST_CASE("ReadWRAM BusRead", "[BusRead]") { Init() uint8_t data; snes.wram->_data[3] = 123; data = snes.bus->read(0x7E0003); - cr_assert_eq(data, 123); + REQUIRE(data == 123); } -Test(BusRead, ReadWRAM2) +TEST_CASE("ReadWRAM2 BusRead", "[BusRead]") { Init() uint8_t data; snes.wram->_data[0x1010] = 123; data = snes.bus->read(0x7E1010); - cr_assert_eq(data, 123); + REQUIRE(data == 123); } -Test(BusRead, ReadWRAMMirror) +TEST_CASE("ReadWRAMMirror BusRead", "[BusRead]") { Init() uint8_t data; snes.wram->_data[0x1010] = 123; data = snes.bus->read(0x1010); - cr_assert_eq(data, 123); + REQUIRE(data == 123); } //////////////////////////// @@ -397,7 +402,7 @@ Test(BusRead, ReadWRAMMirror) // // //////////////////////////// -Test(BusWrite, Write0x0) +TEST_CASE("Write0x0 BusWrite", "[BusWrite]") { Init() @@ -406,53 +411,53 @@ Test(BusWrite, Write0x0) } catch (std::exception &ex) { std::cout << ex.what() << std::endl; } - cr_assert_eq(snes.wram->_data[0], 123); + REQUIRE(snes.wram->_data[0] == 123); } -Test(BusWrite, WriteAPU) +TEST_CASE("WriteAPU BusWrite", "[BusWrite]") { Init() snes.bus->write(0x002143, 123); - cr_assert_eq(snes.apu->_registers.port3, 123); + REQUIRE(snes.apu->_registers.port3 == 123); } -Test(BusWrite, WritePPU) +TEST_CASE("WritePPU BusWrite", "[BusWrite]") { Init() snes.bus->write(0x002106, 123); - cr_assert_eq(snes.ppu->_registers._mosaic.raw, 123); + REQUIRE(snes.ppu->_registers._mosaic.raw == 123); } -Test(BusWrite, WriteCPU) +TEST_CASE("WriteCPU BusWrite", "[BusWrite]") { Init() snes.bus->write(0x00420D, 123); - cr_assert_eq(snes.cpu->_internalRegisters.memsel, 123); + REQUIRE(snes.cpu->_internalRegisters.memsel == 123); } -Test(BusWrite, WriteROM) +TEST_CASE("WriteROM BusWrite", "[BusWrite]") { Init() - cr_assert_throw(snes.bus->write(0x808005, 123), InvalidAction); + REQUIRE_THROWS_AS(snes.bus->write(0x808005, 123), InvalidAction); } -Test(BusWrite, WriteWRAM) +TEST_CASE("WriteWRAM BusWrite", "[BusWrite]") { Init() snes.bus->write(0x7E0002, 123); - cr_assert_eq(snes.wram->_data[2], 123); + REQUIRE(snes.wram->_data[2] == 123); } -Test(BusWrite, WriteSRAM) +TEST_CASE("WriteSRAM BusWrite", "[BusWrite]") { Init() snes.bus->write(0x700009, 123); - cr_assert_eq(snes.sram->_data[9], 123); + REQUIRE(snes.sram->_data[9] == 123); } \ No newline at end of file diff --git a/tests/testRectangleMemory.cpp b/tests/testRectangleMemory.cpp index 69baaab..44e1590 100644 --- a/tests/testRectangleMemory.cpp +++ b/tests/testRectangleMemory.cpp @@ -2,14 +2,13 @@ // Created by anonymus-raccoon on 4/6/20. // -#include -#include +#include #include "tests.hpp" #include "../sources/Memory/RectangleShadow.hpp" using namespace ComSquare; -Test(RectangleMemory, HorizontalRamRead) +TEST_CASE("HorizontalRamRead RectangleMemory", "[RectangleMemory]") { Ram::Ram ram(0xFF, Component::Rom, "Rom"); ram.setMemoryRegion(0x00, 0xFF, 0x0000, 0x0000); @@ -17,21 +16,21 @@ Test(RectangleMemory, HorizontalRamRead) ram._data[i] = i; for (uint24_t i = 0x000000; i < 0xFF0000; i += 0x010000) { uint8_t value = ram.read(ram.getRelativeAddress(i)); - cr_assert_eq(value, i >> 16u, "The ram's read returned 0x%x but the internal ram value was: 0x%x (addr: 0x%06x)", value, i >> 16, i); + REQUIRE(value == i >> 16u); } } -Test(RectangleMemory, HorizontalRamWrite) +TEST_CASE("HorizontalRamWrite RectangleMemory", "[RectangleMemory]") { Ram::Ram ram(0xFF, Component::Rom, "Rom"); ram.setMemoryRegion(0x00, 0xFF, 0x0000, 0x0000); for (uint24_t i = 0x000000; i < 0xFF0000; i += 0x010000) ram.write(ram.getRelativeAddress(i), i >> 16u); for (int i = 0x00; i < 0xFF; i++) - cr_assert_eq(ram._data[i], i, "The ram's write put 0x%x but it should had put: 0x%x (addr: 0x%06x)", ram._data[i], i, i << 16u); + REQUIRE(ram._data[i] == i); } -Test(RectangleMemory, DualLineRamRead) +TEST_CASE("DualLineRamRead RectangleMemory", "[RectangleMemory]") { Ram::Ram ram(0xFF * 2, Component::Rom, "Rom"); ram.setMemoryRegion(0x00, 0xFF, 0x0000, 0x0001); @@ -39,13 +38,13 @@ Test(RectangleMemory, DualLineRamRead) ram._data[i] = i; for (uint24_t i = 0x000000, v = 0; v < 0xFF * 2; i += 0x010000, v += 2) { uint8_t value = ram.read(ram.getRelativeAddress(i)); - cr_assert_eq(value, (uint8_t)(v), "The ram's read returned 0x%x but the internal ram value was: 0x%x (addr: 0x%06x)", value, (uint8_t)(v), i); + REQUIRE(value == (uint8_t)(v)); value = ram.read(ram.getRelativeAddress(i + 1)); - cr_assert_eq(value, (uint8_t)(v + 1), "The ram's read returned 0x%x but the internal ram value was: 0x%x (addr: 0x%06x)", value, (uint8_t)(v + 1), i + 1); + REQUIRE(value == (uint8_t)(v + 1)); } } -Test(RectangleMemory, HorizontalRamShadowRead) +TEST_CASE("HorizontalRamShadowRead RectangleMemory", "[RectangleMemory]") { std::shared_ptr ram = std::make_shared(0xFF, Component::Rom, "Rom"); ram->setMemoryRegion(0x00, 0xFF, 0x0000, 0x0000); @@ -54,10 +53,10 @@ Test(RectangleMemory, HorizontalRamShadowRead) ram->_data[i] = i; for (uint24_t i = 0x008000; i < 0xFF8000; i += 0x010000) { uint8_t v = shadow.read(shadow.getRelativeAddress(i)); - cr_assert_eq(v, i >> 16u, "The ram's read returned 0x%x but the internal ram value was: 0x%x (addr: 0x%06x)", v, i >> 16, i); + REQUIRE(v == i >> 16u); }} -Test(RectangleMemory, HorizontalRamShadowReadWithBankOffset) +TEST_CASE("HorizontalRamShadowReadWithBankOffset RectangleMemory", "[RectangleMemory]") { std::shared_ptr ram = std::make_shared(0xFF, Component::Rom, "Rom"); ram->setMemoryRegion(0x00, 0xFF, 0x0000, 0x0000); @@ -67,11 +66,11 @@ Test(RectangleMemory, HorizontalRamShadowReadWithBankOffset) shadow.setBankOffset(0x80); for (uint24_t i = 0x808000; i < 0xFF8000; i += 0x010000) { uint8_t v = shadow.read(shadow.getRelativeAddress(i)); - cr_assert_eq(v, i >> 16u, "The ram's read returned 0x%x but the internal ram value was: 0x%x (addr: 0x%06x)", v, i >> 16, i); + REQUIRE(v == i >> 16u); } } -Test(RectangleMemory, ShadowOffsetCartridge) +TEST_CASE("ShadowOffsetCartridge RectangleMemory", "[RectangleMemory]") { std::shared_ptr ram = std::make_shared(0x3fff80, Component::Rom, "Rom"); ram->setMemoryRegion(0x80, 0xFF, 0x8000, 0xFFFF); @@ -84,6 +83,6 @@ Test(RectangleMemory, ShadowOffsetCartridge) i += 0x010000 - 0x8000; uint8_t v = shadow.read(shadow.getRelativeAddress(i)); uint8_t r = ram->read(ram->getRelativeAddress(i + 0x8000)); - cr_assert_eq(v, r, "The ram's read returned 0x%x but the internal ram value was: 0x%x (addr: 0x%06x)", v, r, i); + REQUIRE(v == r); } } \ No newline at end of file diff --git a/tests/tests.hpp b/tests/tests.hpp index b37f81a..d9a19a9 100644 --- a/tests/tests.hpp +++ b/tests/tests.hpp @@ -2,28 +2,29 @@ // Created by Melefo on 05/02/2020. // -#ifndef COMSQUARE_TESTS_HPP -#define COMSQUARE_TESTS_HPP +#pragma once + +#include +// The include here is to prevent successive includes of this file to come after the define. +#include #define private public #define protected public #define class struct -#include "../sources/Memory/MemoryBus.hpp" -#include -#include -#include -#include "tests.hpp" -#include "../sources/Renderer/NoRenderer.hpp" -#include "../sources/SNES.hpp" +#include "Memory/MemoryBus.hpp" +#include "Renderer/NoRenderer.hpp" +#include "SNES.hpp" #define Init() \ - Renderer::NoRenderer norenderer(0, 0, 0); \ - SNES snes("../tests/my_cartridge", norenderer); \ - snes.cartridge->_size = 100; \ + Renderer::NoRenderer norenderer(0, 0, 0); \ + SNES snes("../tests/my_cartridge", norenderer); \ + snes.cartridge->_size = 100; \ + delete[] snes.cartridge->_data; \ snes.cartridge->_data = new uint8_t[snes.cartridge->_size]; \ - snes.cartridge->header.mappingMode = Cartridge::LoRom; \ - snes.sram->_size = 100; \ - snes.sram->_data = new uint8_t[snes.cartridge->_size]; - -#endif //COMSQUARE_TESTS_HPP + memset(snes.cartridge->_data, 0, snes.cartridge->_size); \ + snes.cartridge->header.mappingMode = Cartridge::LoRom; \ + snes.sram->_size = 100; \ + delete[] snes.sram->_data; \ + snes.sram->_data = new uint8_t[snes.sram->_size]; \ + memset(snes.sram->_data, 0, snes.cartridge->_size);