parse_program_tests.cpp

#include <catch2/catch_test_macros.hpp>
#include <parse_program.hpp>

TEST_CASE("parse ADD")
{
    SECTION("valid") {
        auto instructions = parse_program("ADD R0, R1, R2");

        std::visit([](const auto& instruction) {
            if constexpr (std::is_same_v<std::decay_t<decltype(instruction)>, AddInstruction>) {
                REQUIRE(instruction.register_1 == Register::R0);
                REQUIRE(instruction.register_2 == Register::R1);
                REQUIRE(instruction.output_register == Register::R2);
            } else {
                throw std::runtime_error("invalid instruction type");
            }
        }, instructions.at(0).value().variant);
    }

    SECTION("invalid register") {
        REQUIRE_THROWS( parse_program("ADD R0, R1, RX") );
        REQUIRE_THROWS( parse_program("ADD 0, R1, R2") );
    }

    SECTION("too few arguments") {
        REQUIRE_THROWS( parse_program("ADD R0, R1") );
    }
}

TEST_CASE("parse SUB")
{
    SECTION("valid") {
        auto instructions = parse_program("SUB R1, R2, R3");

        std::visit([](const auto& instruction) {
            if constexpr (std::is_same_v<std::decay_t<decltype(instruction)>, SubInstruction>) {
                REQUIRE(instruction.register_1 == Register::R1);
                REQUIRE(instruction.register_2 == Register::R2);
                REQUIRE(instruction.output_register == Register::R3);
            } else {
                throw std::runtime_error("invalid instruction type");
            }
        }, instructions.at(0).value().variant);
    }

    SECTION("invalid register") {
        REQUIRE_THROWS( parse_program("SUB R0, R1, RX") );
        REQUIRE_THROWS( parse_program("SUB 0, R1, R2") );
    }

    SECTION("too few arguments") {
        REQUIRE_THROWS( parse_program("SUB R0, R1") );
    }
}

TEST_CASE("parse CMP") 
{
    SECTION("valid") {
        auto instructions = parse_program("CMP R0, R1");

        std::visit([](const auto& instruction) {
            if constexpr (std::is_same_v<std::decay_t<decltype(instruction)>, CompareInstruction>) {
                REQUIRE(instruction.register_1 == Register::R0);
                REQUIRE(instruction.register_2 == Register::R1);
            } else {
                throw std::runtime_error("invalid instruction type");
            }
        }, instructions.at(0).value().variant);
    }

    SECTION("invalid register") {
        REQUIRE_THROWS( parse_program("CMP R0, RX") );
        REQUIRE_THROWS( parse_program("CMP 0, R1") );
    }

    SECTION("too few arguments") {
        REQUIRE_THROWS( parse_program("CMP R0") );
    }
}
    
TEST_CASE("parse LOAD")
{
    SECTION("valid") {
        auto instructions = parse_program("LOAD 42, R2");

        std::visit([](const auto& instruction) {
            if constexpr (std::is_same_v<std::decay_t<decltype(instruction)>, LoadInstruction>) {
                REQUIRE(instruction.memory_address == 42);
                REQUIRE(instruction.output_register == Register::R2);
            } else {
                throw std::runtime_error("invalid instruction type");
            }
        }, instructions.at(0).value().variant);
    }

    SECTION("invalid register") {
        REQUIRE_THROWS( parse_program("LOAD 42, RX") );
    }

    SECTION("invalid memory address") {
        REQUIRE_THROWS( parse_program("LOAD 257, R1") );
    }

    SECTION("too few arguments") {
        REQUIRE_THROWS( parse_program("LOAD 42") );
    }

    SECTION("invalid argument order") {
        REQUIRE_THROWS( parse_program("LOAD R0, 42") );
    }
}
    
TEST_CASE("parse STORE")
{
    SECTION("STORE") {
        auto instructions = parse_program("STORE R1, 99");

        std::visit([](const auto& instruction) {
            if constexpr (std::is_same_v<std::decay_t<decltype(instruction)>, StoreInstruction>) {
                REQUIRE(instruction._register == Register::R1);
                REQUIRE(instruction.memory_address == 99);
            } else {
                throw std::runtime_error("invalid instruction type");
            }
        }, instructions.at(0).value().variant);
    }

    SECTION("invalid register") {
        REQUIRE_THROWS( parse_program("STORE RX, 99") );
    }

    SECTION("invalid memory address") {
        REQUIRE_THROWS( parse_program("STORE R1, 257") );
    }

    SECTION("too few arguments") {
        REQUIRE_THROWS( parse_program("STORE R1") );
    }

    SECTION("invalid argument order") {
        REQUIRE_THROWS( parse_program("STORE 42, R1") );
    }
}

TEST_CASE("parse JMP") 
{
    SECTION("valid") {
        auto instructions = parse_program("JMP 10");

        std::visit([](const auto& instruction) {
            if constexpr (std::is_same_v<std::decay_t<decltype(instruction)>, JumpInstruction>) {
                REQUIRE(instruction.program_counter_index == 10);
            } else {
                throw std::runtime_error("invalid instruction type");
            }
        }, instructions.at(0).value().variant);
    }

    SECTION("invalid memory address") {
        REQUIRE_THROWS( parse_program("JMP 257") );
    }

    SECTION("too few arguments") {
        REQUIRE_THROWS( parse_program("JMP") );
    }
}
    
TEST_CASE("parse JMP_EQ")
{
    SECTION("valid") {
        auto instructions = parse_program("JMP_EQ 20");

        std::visit([](const auto& instruction) {
            if constexpr (std::is_same_v<std::decay_t<decltype(instruction)>, JumpEqualInstruction>) {
                REQUIRE(instruction.program_counter_index == 20);
            } else {
                throw std::runtime_error("invalid instruction type");
            }
        }, instructions.at(0).value().variant);
    }

    SECTION("invalid memory address") {
        REQUIRE_THROWS( parse_program("JMP_EQ 257") );
    }

    SECTION("invalid number of arguments") {
        REQUIRE_THROWS( parse_program("JMP_EQ") );
    }
}
    
TEST_CASE("parse HALT")
{
    SECTION("valid") {
        auto instructions = parse_program("HALT");

        std::visit([](const auto& instruction) {
            REQUIRE(std::is_same_v<std::decay_t<decltype(instruction)>, HaltInstruction>);
        }, instructions.at(0).value().variant);
    }
}

TEST_CASE("parse PRINT")
{
    SECTION("valid") {
        auto instructions = parse_program("PRINT 10");

        std::visit([](const auto& instruction) {
            if constexpr (std::is_same_v<std::decay_t<decltype(instruction)>, PrintInstruction>) {
                REQUIRE(instruction.memory_address == 10);
            } else {
                throw std::runtime_error("invalid instruction type");
            }
        }, instructions.at(0).value().variant);
    }
}