AsmGrader 0.0.0
Loading...
Searching...
No Matches
Macros
test_macros.hpp File Reference
#include <range/v3/all.hpp>
#include <asmgrader/api/assignment.hpp>
#include <asmgrader/api/requirement.hpp>
#include <asmgrader/api/test_base.hpp>
#include <asmgrader/api/test_context.hpp>
#include <asmgrader/common/macros.hpp>
#include <asmgrader/grading_session.hpp>
#include <asmgrader/logging.hpp>
#include <asmgrader/registrars/auto_registrars.hpp>
#include <boost/preprocessor/repetition/repeat.hpp>
Include dependency graph for test_macros.hpp:
This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros

#define ASSIGNMENT(cpp_identifier, name, executable)
 
#define TEST_IMPL(ident, name, ...)
 
#define TEST(name, ...)
 
#define PROF_ONLY_TEST(name, ...)
 Define a test that runs only in professor mode.
 
#define REQUIRE_IMPL(unq_ident, condition, condition_raw_str, ...)
 
#define REQUIRE(condition, ...)
 
#define FILE_METADATA(...)
 
#define REGS_MACRO_IMPL(which)
 
#define W0   REGS_MACRO_IMPL(w0)
 
#define X0   REGS_MACRO_IMPL(x0)
 
#define W1   REGS_MACRO_IMPL(w1)
 
#define X1   REGS_MACRO_IMPL(x1)
 
#define W2   REGS_MACRO_IMPL(w2)
 
#define X2   REGS_MACRO_IMPL(x2)
 
#define W3   REGS_MACRO_IMPL(w3)
 
#define X3   REGS_MACRO_IMPL(x3)
 
#define W4   REGS_MACRO_IMPL(w4)
 
#define X4   REGS_MACRO_IMPL(x4)
 
#define W5   REGS_MACRO_IMPL(w5)
 
#define X5   REGS_MACRO_IMPL(x5)
 
#define W6   REGS_MACRO_IMPL(w6)
 
#define X6   REGS_MACRO_IMPL(x6)
 
#define W7   REGS_MACRO_IMPL(w7)
 
#define X7   REGS_MACRO_IMPL(x7)
 
#define W8   REGS_MACRO_IMPL(w8)
 
#define X8   REGS_MACRO_IMPL(x8)
 
#define W9   REGS_MACRO_IMPL(w9)
 
#define X9   REGS_MACRO_IMPL(x9)
 
#define W10   REGS_MACRO_IMPL(w10)
 
#define X10   REGS_MACRO_IMPL(x10)
 
#define W11   REGS_MACRO_IMPL(w11)
 
#define X11   REGS_MACRO_IMPL(x11)
 
#define W12   REGS_MACRO_IMPL(w12)
 
#define X12   REGS_MACRO_IMPL(x12)
 
#define W13   REGS_MACRO_IMPL(w13)
 
#define X13   REGS_MACRO_IMPL(x13)
 
#define W14   REGS_MACRO_IMPL(w14)
 
#define X14   REGS_MACRO_IMPL(x14)
 
#define W15   REGS_MACRO_IMPL(w15)
 
#define X15   REGS_MACRO_IMPL(x15)
 
#define W16   REGS_MACRO_IMPL(w16)
 
#define X16   REGS_MACRO_IMPL(x16)
 
#define W17   REGS_MACRO_IMPL(w17)
 
#define X17   REGS_MACRO_IMPL(x17)
 
#define W18   REGS_MACRO_IMPL(w18)
 
#define X18   REGS_MACRO_IMPL(x18)
 
#define W19   REGS_MACRO_IMPL(w19)
 
#define X19   REGS_MACRO_IMPL(x19)
 
#define W20   REGS_MACRO_IMPL(w20)
 
#define X20   REGS_MACRO_IMPL(x20)
 
#define W21   REGS_MACRO_IMPL(w21)
 
#define X21   REGS_MACRO_IMPL(x21)
 
#define W22   REGS_MACRO_IMPL(w22)
 
#define X22   REGS_MACRO_IMPL(x22)
 
#define W23   REGS_MACRO_IMPL(w23)
 
#define X23   REGS_MACRO_IMPL(x23)
 
#define W24   REGS_MACRO_IMPL(w24)
 
#define X24   REGS_MACRO_IMPL(x24)
 
#define W25   REGS_MACRO_IMPL(w25)
 
#define X25   REGS_MACRO_IMPL(x25)
 
#define W26   REGS_MACRO_IMPL(w26)
 
#define X26   REGS_MACRO_IMPL(x26)
 
#define W27   REGS_MACRO_IMPL(w27)
 
#define X27   REGS_MACRO_IMPL(x27)
 
#define W28   REGS_MACRO_IMPL(w28)
 
#define X28   REGS_MACRO_IMPL(x28)
 
#define W29   REGS_MACRO_IMPL(w29)
 
#define X29   REGS_MACRO_IMPL(x29)
 
#define W30   REGS_MACRO_IMPL(w30)
 
#define X30   REGS_MACRO_IMPL(x30)
 
#define FP   REGS_MACRO_IMPL(fp)
 
#define LR   REGS_MACRO_IMPL(lr)
 
#define SP   REGS_MACRO_IMPL(sp)
 
#define PC   REGS_MACRO_IMPL(pc)
 
#define PSTATE   REGS_MACRO_IMPL(pstate)
 
#define N   PSTATE.n()
 
#define Z   PSTATE.z()
 
#define C   PSTATE.c()
 
#define V   PSTATE.v()
 

Macro Definition Documentation

◆ ASSIGNMENT

#define ASSIGNMENT ( cpp_identifier,
name,
executable )
Value:
const static Assignment& cpp_identifier = /* NOLINT(misc-use-anonymous-namespace)*/ \
::asmgrader::GlobalRegistrar::get().add(Assignment{name, executable});

◆ C

#define C   PSTATE.c()

◆ FILE_METADATA

#define FILE_METADATA ( ...)
Value:
namespace asmgrader::metadata { \
consteval auto global_file_metadata() { \
using namespace ::asmgrader; /* NOLINT(google-build-using-namespace) */ \
return ::asmgrader::metadata::Metadata{__VA_ARGS__}; \
} \
}
asmgrader::metadata
Definition metadata.hpp:20
asmgrader
Definition asm_buffer.hpp:20

◆ FP

#define FP   REGS_MACRO_IMPL(fp)

◆ LR

#define LR   REGS_MACRO_IMPL(lr)

◆ N

#define N   PSTATE.n()

◆ PC

#define PC   REGS_MACRO_IMPL(pc)

◆ PROF_ONLY_TEST

#define PROF_ONLY_TEST ( name,
... )
Value:
[[maybe_unused]] static void CONCAT(prof_test_unused, __COUNTER__)(TestContext & ctx)
CONCAT
#define CONCAT(a, b)
Definition macros.hpp:6

Define a test that runs only in professor mode.

Usage of this is prefered over TEST("...", ProfOnly) because with this macro, the test body and name will not show up in the final binary. This might allow some determined students to figure out what tests are run on the professor's end through some in-depth analysis.

◆ PSTATE

#define PSTATE   REGS_MACRO_IMPL(pstate)

◆ REGS_MACRO_IMPL

#define REGS_MACRO_IMPL ( which)
Value:
ctx.get_registers().which

◆ REQUIRE

#define REQUIRE ( condition,
... )
Value:
REQUIRE_IMPL(CONCAT(require_unq_, __COUNTER__), condition, #condition, __VA_ARGS__)
REQUIRE_IMPL
#define REQUIRE_IMPL(unq_ident, condition, condition_raw_str,...)
Definition test_macros.hpp:55

◆ REQUIRE_IMPL

#define REQUIRE_IMPL ( unq_ident,
condition,
condition_raw_str,
... )
Value:
do { /* NOLINT(cppcoreguidelines-avoid-do-while) */ \
/*NOLINTNEXTLINE(bugprone-chained-comparison)*/ \
const auto& unq_ident = ::asmgrader::Requirement{asmgrader::Decomposer{} <= condition, \
{condition_raw_str} __VA_OPT__(, ONLY_FIRST(__VA_ARGS__))}; \
bool CONCAT(bool_, unq_ident) = ctx.require(unq_ident); \
} while (false);
asmgrader::Requirement
Definition requirement.hpp:214
ONLY_FIRST
#define ONLY_FIRST(first,...)
Definition macros.hpp:20
asmgrader::Decomposer
Just a tag type for operator overloading purposes Intended use is on the lhs of operator<= e....
Definition decomposer.hpp:22

◆ SP

#define SP   REGS_MACRO_IMPL(sp)

◆ TEST

#define TEST ( name,
... )
Value:
TEST_IMPL(CONCAT(TEST__, __COUNTER__), name __VA_OPT__(, ) __VA_ARGS__)
TEST_IMPL
#define TEST_IMPL(ident, name,...)
Definition test_macros.hpp:25

◆ TEST_IMPL

#define TEST_IMPL ( ident,
name,
... )
Value:
namespace { \
class ident final : public ::asmgrader::TestBase \
{ \
public: \
using TestBase::TestBase; \
void run(::asmgrader::TestContext& ctx) override; \
}; \
using namespace ::asmgrader::metadata; /*NOLINT(google-build-using-namespace)*/ \
constexpr auto CONCAT(ident, \
__metadata) = ::asmgrader::metadata::create(::asmgrader::metadata::DEFAULT_METADATA, \
::asmgrader::metadata::global_file_metadata() \
__VA_OPT__(, ) __VA_ARGS__); \
const ::asmgrader::TestAutoRegistrar<ident> CONCAT(ident, __registrar){name, CONCAT(ident, __metadata)}; \
} \
void ident::run([[maybe_unused]] ::asmgrader::TestContext& ctx)
asmgrader::TestBase
Base class primarily for a user-written test.
Definition test_base.hpp:17
asmgrader::TestBase::run
virtual void run(TestContext &ctx)=0
asmgrader::TestContext
User-facing API for use within an assignment test case for: Interacting with or querying data for the...
Definition test_context.hpp:44
asmgrader::metadata::create
consteval auto create(Args &&... args)
Definition metadata.hpp:173
asmgrader::metadata::DEFAULT_METADATA
constexpr Metadata DEFAULT_METADATA
Definition metadata.hpp:274

◆ V

#define V   PSTATE.v()

◆ W0

#define W0   REGS_MACRO_IMPL(w0)

◆ W1

#define W1   REGS_MACRO_IMPL(w1)

◆ W10

#define W10   REGS_MACRO_IMPL(w10)

◆ W11

#define W11   REGS_MACRO_IMPL(w11)

◆ W12

#define W12   REGS_MACRO_IMPL(w12)

◆ W13

#define W13   REGS_MACRO_IMPL(w13)

◆ W14

#define W14   REGS_MACRO_IMPL(w14)

◆ W15

#define W15   REGS_MACRO_IMPL(w15)

◆ W16

#define W16   REGS_MACRO_IMPL(w16)

◆ W17

#define W17   REGS_MACRO_IMPL(w17)

◆ W18

#define W18   REGS_MACRO_IMPL(w18)

◆ W19

#define W19   REGS_MACRO_IMPL(w19)

◆ W2

#define W2   REGS_MACRO_IMPL(w2)

◆ W20

#define W20   REGS_MACRO_IMPL(w20)

◆ W21

#define W21   REGS_MACRO_IMPL(w21)

◆ W22

#define W22   REGS_MACRO_IMPL(w22)

◆ W23

#define W23   REGS_MACRO_IMPL(w23)

◆ W24

#define W24   REGS_MACRO_IMPL(w24)

◆ W25

#define W25   REGS_MACRO_IMPL(w25)

◆ W26

#define W26   REGS_MACRO_IMPL(w26)

◆ W27

#define W27   REGS_MACRO_IMPL(w27)

◆ W28

#define W28   REGS_MACRO_IMPL(w28)

◆ W29

#define W29   REGS_MACRO_IMPL(w29)

◆ W3

#define W3   REGS_MACRO_IMPL(w3)

◆ W30

#define W30   REGS_MACRO_IMPL(w30)

◆ W4

#define W4   REGS_MACRO_IMPL(w4)

◆ W5

#define W5   REGS_MACRO_IMPL(w5)

◆ W6

#define W6   REGS_MACRO_IMPL(w6)

◆ W7

#define W7   REGS_MACRO_IMPL(w7)

◆ W8

#define W8   REGS_MACRO_IMPL(w8)

◆ W9

#define W9   REGS_MACRO_IMPL(w9)

◆ X0

#define X0   REGS_MACRO_IMPL(x0)

◆ X1

#define X1   REGS_MACRO_IMPL(x1)

◆ X10

#define X10   REGS_MACRO_IMPL(x10)

◆ X11

#define X11   REGS_MACRO_IMPL(x11)

◆ X12

#define X12   REGS_MACRO_IMPL(x12)

◆ X13

#define X13   REGS_MACRO_IMPL(x13)

◆ X14

#define X14   REGS_MACRO_IMPL(x14)

◆ X15

#define X15   REGS_MACRO_IMPL(x15)

◆ X16

#define X16   REGS_MACRO_IMPL(x16)

◆ X17

#define X17   REGS_MACRO_IMPL(x17)

◆ X18

#define X18   REGS_MACRO_IMPL(x18)

◆ X19

#define X19   REGS_MACRO_IMPL(x19)

◆ X2

#define X2   REGS_MACRO_IMPL(x2)

◆ X20

#define X20   REGS_MACRO_IMPL(x20)

◆ X21

#define X21   REGS_MACRO_IMPL(x21)

◆ X22

#define X22   REGS_MACRO_IMPL(x22)

◆ X23

#define X23   REGS_MACRO_IMPL(x23)

◆ X24

#define X24   REGS_MACRO_IMPL(x24)

◆ X25

#define X25   REGS_MACRO_IMPL(x25)

◆ X26

#define X26   REGS_MACRO_IMPL(x26)

◆ X27

#define X27   REGS_MACRO_IMPL(x27)

◆ X28

#define X28   REGS_MACRO_IMPL(x28)

◆ X29

#define X29   REGS_MACRO_IMPL(x29)

◆ X3

#define X3   REGS_MACRO_IMPL(x3)

◆ X30

#define X30   REGS_MACRO_IMPL(x30)

◆ X4

#define X4   REGS_MACRO_IMPL(x4)

◆ X5

#define X5   REGS_MACRO_IMPL(x5)

◆ X6

#define X6   REGS_MACRO_IMPL(x6)

◆ X7

#define X7   REGS_MACRO_IMPL(x7)

◆ X8

#define X8   REGS_MACRO_IMPL(x8)

◆ X9

#define X9   REGS_MACRO_IMPL(x9)

◆ Z

#define Z   PSTATE.z()