942 lines
32 KiB
C++
942 lines
32 KiB
C++
#include "gtest/gtest.h"
|
|
#include "test-utils.h"
|
|
|
|
using namespace std;
|
|
using namespace emu_6502;
|
|
|
|
const uint8_t AND_IMM = 0x29;
|
|
const uint8_t AND_ZPG = 0x25;
|
|
const uint8_t AND_ZPG_X = 0x35;
|
|
const uint8_t AND_ABS = 0x2D;
|
|
const uint8_t AND_ABS_X = 0x3D;
|
|
const uint8_t AND_ABS_Y = 0x39;
|
|
const uint8_t AND_IND_X = 0x21;
|
|
const uint8_t AND_IND_Y = 0x31;
|
|
|
|
const uint8_t ORA_IMM = 0x09;
|
|
const uint8_t ORA_ZPG = 0x05;
|
|
const uint8_t ORA_ZPG_X = 0x15;
|
|
const uint8_t ORA_ABS = 0x0D;
|
|
const uint8_t ORA_ABS_X = 0x1D;
|
|
const uint8_t ORA_ABS_Y = 0x19;
|
|
const uint8_t ORA_IND_X = 0x01;
|
|
const uint8_t ORA_IND_Y = 0x11;
|
|
|
|
const uint8_t EOR_IMM = 0x49;
|
|
const uint8_t EOR_ZPG = 0x45;
|
|
const uint8_t EOR_ZPG_X = 0x55;
|
|
const uint8_t EOR_ABS = 0x4D;
|
|
const uint8_t EOR_ABS_X = 0x5D;
|
|
const uint8_t EOR_ABS_Y = 0x59;
|
|
const uint8_t EOR_IND_X = 0x41;
|
|
const uint8_t EOR_IND_Y = 0x51;
|
|
|
|
const uint8_t BIT_ZPG = 0x24;
|
|
const uint8_t BIT_ABS = 0x2C;
|
|
|
|
const uint8_t ASL_ACC = 0x0A;
|
|
const uint8_t ASL_ZPG = 0x06;
|
|
const uint8_t ASL_ZPG_X = 0x16;
|
|
const uint8_t ASL_ABS = 0x0E;
|
|
const uint8_t ASL_ABS_X = 0x1E;
|
|
|
|
const uint8_t LSR_ACC = 0x4A;
|
|
const uint8_t LSR_ZPG = 0x46;
|
|
const uint8_t LSR_ZPG_X = 0x56;
|
|
const uint8_t LSR_ABS = 0x4E;
|
|
const uint8_t LSR_ABS_X = 0x5E;
|
|
|
|
const uint8_t ROL_ACC = 0x2A;
|
|
const uint8_t ROL_ZPG = 0x26;
|
|
const uint8_t ROL_ZPG_X = 0x36;
|
|
const uint8_t ROL_ABS = 0x2E;
|
|
const uint8_t ROL_ABS_X = 0x3E;
|
|
|
|
const uint8_t ROR_ACC = 0x6A;
|
|
const uint8_t ROR_ZPG = 0x66;
|
|
const uint8_t ROR_ZPG_X = 0x76;
|
|
const uint8_t ROR_ABS = 0x6E;
|
|
const uint8_t ROR_ABS_X = 0x7E;
|
|
|
|
TEST(LoadOpcodeHandlerContainer, AND_IMM) {
|
|
auto machine = create_machine({AND_IMM, 0x23});
|
|
machine->get_cpu().get_a().set_value(0x13);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x03, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, AND_IMM_ZeroFlag) {
|
|
auto machine = create_machine({AND_IMM, 0x11});
|
|
machine->get_cpu().get_a().set_value(0x22);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0, machine->get_cpu().get_a().get_value());
|
|
RegisterFlagSet flags{};
|
|
flags.zero = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, AND_IMM_NegativeFlag) {
|
|
auto machine = create_machine({AND_IMM, 0xF0});
|
|
machine->get_cpu().get_a().set_value(0xA1);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0xA0, machine->get_cpu().get_a().get_value());
|
|
RegisterFlagSet flags{};
|
|
flags.negative = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, AND_ZPG) {
|
|
auto machine = create_machine({AND_ZPG, 0xF5});
|
|
machine->get_memory().set_at(0xF5, 0x55);
|
|
machine->get_cpu().get_a().set_value(0x41);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x41, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, AND_ZPG_X) {
|
|
auto machine = create_machine({AND_ZPG_X, 0x30});
|
|
machine->get_cpu().get_x().set_value(0x50);
|
|
machine->get_memory().set_at(0x80, 0x55);
|
|
machine->get_cpu().get_a().set_value(0x41);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x41, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, AND_ABS) {
|
|
auto machine = create_machine({AND_ABS, 0x30, 0x05});
|
|
machine->get_memory().set_at(0x0530, 0x55);
|
|
machine->get_cpu().get_a().set_value(0x41);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x41, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, AND_ABS_X) {
|
|
auto machine = create_machine({AND_ABS_X, 0x30, 0x05});
|
|
machine->get_cpu().get_x().set_value(0xA);
|
|
machine->get_memory().set_at(0x053A, 0x55);
|
|
machine->get_cpu().get_a().set_value(0x41);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x41, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, AND_ABS_Y) {
|
|
auto machine = create_machine({AND_ABS_Y, 0x30, 0x05});
|
|
machine->get_cpu().get_y().set_value(0xA);
|
|
machine->get_memory().set_at(0x053A, 0x55);
|
|
machine->get_cpu().get_a().set_value(0x41);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x41, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, AND_IND_X) {
|
|
auto machine = create_machine({AND_IND_X, 0x55});
|
|
machine->get_cpu().get_x().set_value(0x22);
|
|
machine->get_cpu().get_a().set_value(0x41);
|
|
machine->get_memory().set_at(0x77, 0x34);
|
|
machine->get_memory().set_at(0x78, 0x12);
|
|
machine->get_memory().set_at(0x1234, 0x43);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x41, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, AND_IND_Y) {
|
|
auto machine = create_machine({AND_IND_Y, 0x41});
|
|
machine->get_cpu().get_y().set_value(0x22);
|
|
machine->get_cpu().get_a().set_value(0xFF);
|
|
machine->get_memory().set_at(0x41, 0x34);
|
|
machine->get_memory().set_at(0x42, 0x12);
|
|
machine->get_memory().set_at(0x1256, 0x29);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x29, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ORA_IMM) {
|
|
auto machine = create_machine({ORA_IMM, 0x30});
|
|
machine->get_cpu().get_a().set_value(0x13);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x33, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ORA_IMM_ZeroFlag) {
|
|
auto machine = create_machine({ORA_IMM, 0x00});
|
|
machine->get_cpu().get_a().set_value(0x00);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0, machine->get_cpu().get_a().get_value());
|
|
RegisterFlagSet flags{};
|
|
flags.zero = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ORA_IMM_NegativeFlag) {
|
|
auto machine = create_machine({ORA_IMM, 0xF0});
|
|
machine->get_cpu().get_a().set_value(0xA1);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0xF1, machine->get_cpu().get_a().get_value());
|
|
RegisterFlagSet flags{};
|
|
flags.negative = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ORA_ZPG) {
|
|
auto machine = create_machine({ORA_ZPG, 0xF5});
|
|
machine->get_memory().set_at(0xF5, 0x10);
|
|
machine->get_cpu().get_a().set_value(0x25);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x35, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ORA_ZPG_X) {
|
|
auto machine = create_machine({ORA_ZPG_X, 0x30});
|
|
machine->get_cpu().get_x().set_value(0x50);
|
|
machine->get_memory().set_at(0x80, 0x81);
|
|
machine->get_cpu().get_a().set_value(0x42);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0xC3, machine->get_cpu().get_a().get_value());
|
|
RegisterFlagSet flags{};
|
|
flags.negative = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ORA_ABS) {
|
|
auto machine = create_machine({ORA_ABS, 0x30, 0x05});
|
|
machine->get_memory().set_at(0x0530, 0x55);
|
|
machine->get_cpu().get_a().set_value(0x41);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x55, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ORA_ABS_X) {
|
|
auto machine = create_machine({ORA_ABS_X, 0x30, 0x05});
|
|
machine->get_cpu().get_x().set_value(0xA);
|
|
machine->get_memory().set_at(0x053A, 0x40);
|
|
machine->get_cpu().get_a().set_value(0x53);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x53, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ORA_ABS_Y) {
|
|
auto machine = create_machine({ORA_ABS_Y, 0x30, 0x05});
|
|
machine->get_cpu().get_y().set_value(0xA);
|
|
machine->get_memory().set_at(0x053A, 0x20);
|
|
machine->get_cpu().get_a().set_value(0x02);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x22, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ORA_IND_X) {
|
|
auto machine = create_machine({ORA_IND_X, 0x55});
|
|
machine->get_cpu().get_x().set_value(0x22);
|
|
machine->get_cpu().get_a().set_value(0x18);
|
|
machine->get_memory().set_at(0x77, 0x34);
|
|
machine->get_memory().set_at(0x78, 0x12);
|
|
machine->get_memory().set_at(0x1234, 0x18);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x18, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ORA_IND_Y) {
|
|
auto machine = create_machine({ORA_IND_Y, 0x41});
|
|
machine->get_cpu().get_y().set_value(0x22);
|
|
machine->get_cpu().get_a().set_value(0xFF);
|
|
machine->get_memory().set_at(0x41, 0x34);
|
|
machine->get_memory().set_at(0x42, 0x12);
|
|
machine->get_memory().set_at(0x1256, 0x23);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0xFF, machine->get_cpu().get_a().get_value());
|
|
RegisterFlagSet flags{};
|
|
flags.negative = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, EOR_IMM) {
|
|
auto machine = create_machine({EOR_IMM, 0x30});
|
|
machine->get_cpu().get_a().set_value(0x13);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x23, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, EOR_IMM_ZeroFlag) {
|
|
auto machine = create_machine({EOR_IMM, 0x11});
|
|
machine->get_cpu().get_a().set_value(0x11);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0, machine->get_cpu().get_a().get_value());
|
|
RegisterFlagSet flags{};
|
|
flags.zero = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, EOR_IMM_NegativeFlag) {
|
|
auto machine = create_machine({EOR_IMM, 0xF0});
|
|
machine->get_cpu().get_a().set_value(0x05);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0xF5, machine->get_cpu().get_a().get_value());
|
|
RegisterFlagSet flags{};
|
|
flags.negative = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, EOR_ZPG) {
|
|
auto machine = create_machine({EOR_ZPG, 0xF5});
|
|
machine->get_memory().set_at(0xF5, 0x31);
|
|
machine->get_cpu().get_a().set_value(0x25);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x14, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, EOR_ZPG_X) {
|
|
auto machine = create_machine({EOR_ZPG_X, 0x30});
|
|
machine->get_cpu().get_x().set_value(0x50);
|
|
machine->get_memory().set_at(0x80, 0x31);
|
|
machine->get_cpu().get_a().set_value(0x23);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x12, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, EOR_ABS) {
|
|
auto machine = create_machine({EOR_ABS, 0x30, 0x05});
|
|
machine->get_memory().set_at(0x0530, 0x55);
|
|
machine->get_cpu().get_a().set_value(0x41);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x14, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, EOR_ABS_X) {
|
|
auto machine = create_machine({EOR_ABS_X, 0x30, 0x05});
|
|
machine->get_cpu().get_x().set_value(0xA);
|
|
machine->get_memory().set_at(0x053A, 0x40);
|
|
machine->get_cpu().get_a().set_value(0x53);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x13, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, EOR_ABS_Y) {
|
|
auto machine = create_machine({EOR_ABS_Y, 0x30, 0x05});
|
|
machine->get_cpu().get_y().set_value(0xA);
|
|
machine->get_memory().set_at(0x053A, 0x20);
|
|
machine->get_cpu().get_a().set_value(0x02);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x22, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, EOR_IND_X) {
|
|
auto machine = create_machine({EOR_IND_X, 0x55});
|
|
machine->get_cpu().get_x().set_value(0x22);
|
|
machine->get_cpu().get_a().set_value(0x19);
|
|
machine->get_memory().set_at(0x77, 0x34);
|
|
machine->get_memory().set_at(0x78, 0x12);
|
|
machine->get_memory().set_at(0x1234, 0x28);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x31, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, EOR_IND_Y) {
|
|
auto machine = create_machine({EOR_IND_Y, 0x41});
|
|
machine->get_cpu().get_y().set_value(0x22);
|
|
machine->get_cpu().get_a().set_value(0x35);
|
|
machine->get_memory().set_at(0x41, 0x34);
|
|
machine->get_memory().set_at(0x42, 0x12);
|
|
machine->get_memory().set_at(0x1256, 0x23);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x16, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, BIT_ZPG) {
|
|
auto machine = create_machine({BIT_ZPG, 0x41});
|
|
machine->get_cpu().get_a().set_value(0x23);
|
|
machine->get_memory().set_at(0x41, 0x35);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x23, machine->get_cpu().get_a().get_value());
|
|
ASSERT_EQ(0x35, machine->get_memory().get_at(0x41));
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, BIT_ZPG_ZeroFlag) {
|
|
auto machine = create_machine({BIT_ZPG, 0x41});
|
|
machine->get_cpu().get_a().set_value(0x11);
|
|
machine->get_memory().set_at(0x41, 0x22);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x11, machine->get_cpu().get_a().get_value());
|
|
ASSERT_EQ(0x22, machine->get_memory().get_at(0x41));
|
|
RegisterFlagSet flags{};
|
|
flags.zero = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, BIT_ZPG_NegativeFlag) {
|
|
auto machine = create_machine({BIT_ZPG, 0x41});
|
|
machine->get_cpu().get_a().set_value(0x23);
|
|
machine->get_memory().set_at(0x41, 0xa5);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x23, machine->get_cpu().get_a().get_value());
|
|
ASSERT_EQ(0xa5, machine->get_memory().get_at(0x41));
|
|
RegisterFlagSet flags{};
|
|
flags.negative = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, BIT_ZPG_OverflowFlag) {
|
|
auto machine = create_machine({BIT_ZPG, 0x41});
|
|
machine->get_cpu().get_a().set_value(0x23);
|
|
machine->get_memory().set_at(0x41, 0x45);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x23, machine->get_cpu().get_a().get_value());
|
|
ASSERT_EQ(0x45, machine->get_memory().get_at(0x41));
|
|
RegisterFlagSet flags{};
|
|
flags.overflow = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, BIT_ZPG_ZeroNegativeAndOverflowFlag) {
|
|
auto machine = create_machine({BIT_ZPG, 0x41});
|
|
machine->get_cpu().get_a().set_value(0x02);
|
|
machine->get_memory().set_at(0x41, 0xc5);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x02, machine->get_cpu().get_a().get_value());
|
|
ASSERT_EQ(0xc5, machine->get_memory().get_at(0x41));
|
|
RegisterFlagSet flags{};
|
|
flags.overflow = true;
|
|
flags.negative = true;
|
|
flags.zero = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, BIT_ABS) {
|
|
auto machine = create_machine({BIT_ABS, 0x41, 0x90});
|
|
machine->get_cpu().get_a().set_value(0x23);
|
|
machine->get_memory().set_at(0x9041, 0x35);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x23, machine->get_cpu().get_a().get_value());
|
|
ASSERT_EQ(0x35, machine->get_memory().get_at(0x9041));
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ASL_ACC) {
|
|
auto machine = create_machine({ASL_ACC});
|
|
machine->get_cpu().get_a().set_value(0x09);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x12, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ASL_ACC_CarryFlag) {
|
|
auto machine = create_machine({ASL_ACC});
|
|
machine->get_cpu().get_a().set_value(0x99);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x32, machine->get_cpu().get_a().get_value());
|
|
RegisterFlagSet flags{};
|
|
flags.carry = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ASL_ACC_ZeroFlag) {
|
|
auto machine = create_machine({ASL_ACC});
|
|
machine->get_cpu().get_a().set_value(0x80);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x0, machine->get_cpu().get_a().get_value());
|
|
RegisterFlagSet flags{};
|
|
flags.carry = true;
|
|
flags.zero = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ASL_ACC_NegativeFlag) {
|
|
auto machine = create_machine({ASL_ACC});
|
|
machine->get_cpu().get_a().set_value(0xc0);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x80, machine->get_cpu().get_a().get_value());
|
|
RegisterFlagSet flags{};
|
|
flags.carry = true;
|
|
flags.negative = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ASL_ZPG) {
|
|
auto machine = create_machine({ASL_ZPG, 0x10});
|
|
machine->get_memory().set_at(0x10, 0x09);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x12, machine->get_memory().get_at(0x10));
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ASL_ZPG_CarryFlag) {
|
|
auto machine = create_machine({ASL_ZPG, 0x10});
|
|
machine->get_memory().set_at(0x10, 0x99);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x32, machine->get_memory().get_at(0x10));
|
|
RegisterFlagSet flags{};
|
|
flags.carry = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ASL_ZPG_ZeroFlag) {
|
|
auto machine = create_machine({ASL_ZPG, 0x10});
|
|
machine->get_memory().set_at(0x10, 0x80);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x0, machine->get_memory().get_at(0x10));
|
|
RegisterFlagSet flags{};
|
|
flags.carry = true;
|
|
flags.zero = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ASL_ZPG_NegativeFlag) {
|
|
auto machine = create_machine({ASL_ZPG, 0x10});
|
|
machine->get_memory().set_at(0x10, 0xc0);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x80, machine->get_memory().get_at(0x10));
|
|
RegisterFlagSet flags{};
|
|
flags.carry = true;
|
|
flags.negative = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ASL_ZPG_X) {
|
|
auto machine = create_machine({ASL_ZPG_X, 0x10});
|
|
machine->get_cpu().get_x().set_value(0x5);
|
|
machine->get_memory().set_at(0x15, 0x09);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x12, machine->get_memory().get_at(0x15));
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ASL_ABS) {
|
|
auto machine = create_machine({ASL_ABS, 0x10, 0x85});
|
|
machine->get_memory().set_at(0x8510, 0x09);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x12, machine->get_memory().get_at(0x8510));
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ASL_ABS_X) {
|
|
auto machine = create_machine({ASL_ABS_X, 0x10, 0x85});
|
|
machine->get_cpu().get_x().set_value(0x5);
|
|
machine->get_memory().set_at(0x8515, 0x09);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x12, machine->get_memory().get_at(0x8515));
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, LSR_ACC) {
|
|
auto machine = create_machine({LSR_ACC});
|
|
machine->get_cpu().get_a().set_value(0x8);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x4, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, LSR_ACC_CarryFlag) {
|
|
auto machine = create_machine({LSR_ACC});
|
|
machine->get_cpu().get_a().set_value(0x9);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x4, machine->get_cpu().get_a().get_value());
|
|
RegisterFlagSet flags{};
|
|
flags.carry = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, LSR_ACC_ZeroFlag) {
|
|
auto machine = create_machine({LSR_ACC});
|
|
machine->get_cpu().get_a().set_value(1);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0, machine->get_cpu().get_a().get_value());
|
|
RegisterFlagSet flags{};
|
|
flags.carry = true;
|
|
flags.zero = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, LSR_ZPG) {
|
|
auto machine = create_machine({LSR_ZPG, 0x5});
|
|
machine->get_memory().set_at(0x5, 0x8);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x4, machine->get_memory().get_at(0x5));
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, LSR_ZPG_CarryFlag) {
|
|
auto machine = create_machine({LSR_ZPG, 0x5});
|
|
machine->get_memory().set_at(0x5, 0x9);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x4, machine->get_memory().get_at(0x5));
|
|
RegisterFlagSet flags{};
|
|
flags.carry = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, LSR_ZPG_ZeroFlag) {
|
|
auto machine = create_machine({LSR_ZPG, 0x5});
|
|
machine->get_memory().set_at(0x5, 1);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0, machine->get_memory().get_at(0x5));
|
|
RegisterFlagSet flags{};
|
|
flags.carry = true;
|
|
flags.zero = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, LSR_ZPG_X) {
|
|
auto machine = create_machine({LSR_ZPG_X, 0x5});
|
|
machine->get_cpu().get_x().set_value(0x5);
|
|
machine->get_memory().set_at(0x0a, 0x8);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x4, machine->get_memory().get_at(0xa));
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, LSR_ABS) {
|
|
auto machine = create_machine({LSR_ABS, 0x5, 0x8});
|
|
machine->get_memory().set_at(0x805, 0x8);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x4, machine->get_memory().get_at(0x805));
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, LSR_ABS_X) {
|
|
auto machine = create_machine({LSR_ABS_X, 0x5, 0x8});
|
|
machine->get_cpu().get_x().set_value(0x5);
|
|
machine->get_memory().set_at(0x80a, 0x8);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x4, machine->get_memory().get_at(0x80a));
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ROL_ACC) {
|
|
auto machine = create_machine({ROL_ACC});
|
|
machine->get_cpu().get_a().set_value(0x09);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x12, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ROL_ACC_OldCarry) {
|
|
auto machine = create_machine({ROL_ACC});
|
|
machine->get_cpu().get_a().set_value(0x09);
|
|
machine->get_cpu().get_ps().set_carry(true);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x13, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ROL_ACC_CarryFlag) {
|
|
auto machine = create_machine({ROL_ACC});
|
|
machine->get_cpu().get_a().set_value(0x89);
|
|
machine->get_cpu().get_ps().set_carry(true);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x13, machine->get_cpu().get_a().get_value());
|
|
RegisterFlagSet flags{};
|
|
flags.carry = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ROL_ACC_NegativeFlag) {
|
|
auto machine = create_machine({ROL_ACC});
|
|
machine->get_cpu().get_a().set_value(0xc9);
|
|
machine->get_cpu().get_ps().set_carry(true);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x93, machine->get_cpu().get_a().get_value());
|
|
RegisterFlagSet flags{};
|
|
flags.carry = true;
|
|
flags.negative = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ROL_ACC_ZeroFlag) {
|
|
auto machine = create_machine({ROL_ACC});
|
|
machine->get_cpu().get_a().set_value(0x80);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x0, machine->get_cpu().get_a().get_value());
|
|
RegisterFlagSet flags{};
|
|
flags.carry = true;
|
|
flags.zero = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ROL_ZPG) {
|
|
auto machine = create_machine({ROL_ZPG, 0x10});
|
|
machine->get_memory().set_at(0x10, 0x09);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x12, machine->get_memory().get_at(0x10));
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ROL_ZPG_OldCarry) {
|
|
auto machine = create_machine({ROL_ZPG, 0x10});
|
|
machine->get_memory().set_at(0x10, 0x09);
|
|
machine->get_cpu().get_ps().set_carry(true);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x13, machine->get_memory().get_at(0x10));
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ROL_ZPG_CarryFlag) {
|
|
auto machine = create_machine({ROL_ZPG, 0x10});
|
|
machine->get_memory().set_at(0x10, 0x89);
|
|
machine->get_cpu().get_ps().set_carry(true);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x13, machine->get_memory().get_at(0x10));
|
|
RegisterFlagSet flags{};
|
|
flags.carry = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ROL_ZPG_NegativeFlag) {
|
|
auto machine = create_machine({ROL_ZPG, 0x10});
|
|
machine->get_memory().set_at(0x10, 0xc9);
|
|
machine->get_cpu().get_ps().set_carry(true);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x93, machine->get_memory().get_at(0x10));
|
|
RegisterFlagSet flags{};
|
|
flags.carry = true;
|
|
flags.negative = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ROL_ZPG_ZeroFlag) {
|
|
auto machine = create_machine({ROL_ZPG, 0x10});
|
|
machine->get_memory().set_at(0x10, 0x80);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x0, machine->get_memory().get_at(0x10));
|
|
RegisterFlagSet flags{};
|
|
flags.carry = true;
|
|
flags.zero = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ROL_ZPG_X) {
|
|
auto machine = create_machine({ROL_ZPG_X, 0x10});
|
|
machine->get_cpu().get_x().set_value(0x5);
|
|
machine->get_memory().set_at(0x15, 0x09);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x12, machine->get_memory().get_at(0x15));
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ROL_ABS) {
|
|
auto machine = create_machine({ROL_ABS, 0x10, 0x11});
|
|
machine->get_memory().set_at(0x1110, 0x09);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x12, machine->get_memory().get_at(0x1110));
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ROL_ABS_X) {
|
|
auto machine = create_machine({ROL_ABS_X, 0x10, 0x11});
|
|
machine->get_cpu().get_x().set_value(0x5);
|
|
machine->get_memory().set_at(0x1115, 0x09);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x12, machine->get_memory().get_at(0x1115));
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ROR_ACC) {
|
|
auto machine = create_machine({ROR_ACC});
|
|
machine->get_cpu().get_a().set_value(0x08);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x4, machine->get_cpu().get_a().get_value());
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ROR_ACC_OldCarry) {
|
|
auto machine = create_machine({ROR_ACC});
|
|
machine->get_cpu().get_ps().set_carry(true);
|
|
machine->get_cpu().get_a().set_value(0x08);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x84, machine->get_cpu().get_a().get_value());
|
|
RegisterFlagSet flags{};
|
|
flags.negative = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ROR_ACC_NegativeAndCarryFlag) {
|
|
auto machine = create_machine({ROR_ACC});
|
|
machine->get_cpu().get_ps().set_carry(true);
|
|
machine->get_cpu().get_a().set_value(0x09);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x84, machine->get_cpu().get_a().get_value());
|
|
RegisterFlagSet flags{};
|
|
flags.carry = true;
|
|
flags.negative = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ROR_ACC_ZeroFlag) {
|
|
auto machine = create_machine({ROR_ACC});
|
|
machine->get_cpu().get_a().set_value(0x01);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x0, machine->get_cpu().get_a().get_value());
|
|
RegisterFlagSet flags{};
|
|
flags.carry = true;
|
|
flags.zero = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ROR_ZPG) {
|
|
auto machine = create_machine({ROR_ZPG, 0x10});
|
|
machine->get_memory().set_at(0x10, 0x08);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x4, machine->get_memory().get_at(0x10));
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ROR_ZPG_OldCarry) {
|
|
auto machine = create_machine({ROR_ZPG, 0x10});
|
|
machine->get_cpu().get_ps().set_carry(true);
|
|
machine->get_memory().set_at(0x10, 0x08);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x84, machine->get_memory().get_at(0x10));
|
|
RegisterFlagSet flags{};
|
|
flags.negative = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ROR_ZPG_NegativeAndCarryFlag) {
|
|
auto machine = create_machine({ROR_ZPG, 0x10});
|
|
machine->get_cpu().get_ps().set_carry(true);
|
|
machine->get_memory().set_at(0x10, 0x09);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x84, machine->get_memory().get_at(0x10));
|
|
RegisterFlagSet flags{};
|
|
flags.carry = true;
|
|
flags.negative = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ROR_ZPG_ZeroFlag) {
|
|
auto machine = create_machine({ROR_ZPG, 0x10});
|
|
machine->get_memory().set_at(0x10, 0x01);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x0, machine->get_memory().get_at(0x10));
|
|
RegisterFlagSet flags{};
|
|
flags.carry = true;
|
|
flags.zero = true;
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), flags));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ROR_ZPG_X) {
|
|
auto machine = create_machine({ROR_ZPG_X, 0x10});
|
|
machine->get_cpu().get_x().set_value(0x5);
|
|
machine->get_memory().set_at(0x15, 0x08);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x4, machine->get_memory().get_at(0x15));
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ROR_ABS) {
|
|
auto machine = create_machine({ROR_ABS, 0x10, 0x75});
|
|
machine->get_memory().set_at(0x7510, 0x08);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x4, machine->get_memory().get_at(0x7510));
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|
|
|
|
TEST(LoadOpcodeHandlerContainer, ROR_ABS_X) {
|
|
auto machine = create_machine({ROR_ABS_X, 0x10, 0x75});
|
|
machine->get_cpu().get_x().set_value(0x5);
|
|
machine->get_memory().set_at(0x7515, 0x08);
|
|
machine->execute();
|
|
|
|
ASSERT_EQ(0x4, machine->get_memory().get_at(0x7515));
|
|
ASSERT_TRUE(are_flags_set(machine->get_cpu().get_ps(), RegisterFlagSet{}));
|
|
}
|