test_context.hpp

Go to the documentation of this file.

#pragma once
 
#include <asmgrader/api/asm_buffer.hpp>
#include <asmgrader/api/asm_function.hpp>
#include <asmgrader/api/asm_symbol.hpp>
#include <asmgrader/api/registers_state.hpp>
#include <asmgrader/api/requirement.hpp>
#include <asmgrader/common/aliases.hpp>
#include <asmgrader/common/error_types.hpp>
#include <asmgrader/common/functional.hpp>
#include <asmgrader/grading_session.hpp>
#include <asmgrader/logging.hpp>
#include <asmgrader/program/program.hpp>
#include <asmgrader/subprocess/memory/concepts.hpp>
#include <asmgrader/subprocess/run_result.hpp>
#include <asmgrader/subprocess/syscall_record.hpp>
 
#include <fmt/base.h>
#include <fmt/format.h>
 
#include <array>
#include <concepts>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <optional>
#include <string>
#include <string_view>
#include <type_traits>
#include <utility>
#include <vector>
 
#include <sys/user.h>
 
namespace asmgrader {
 
class TestBase;
 
class TestContext
{
public:
    explicit TestContext(TestBase& test, Program program,
                         std::function<void(const RequirementResult&)> on_requirement = common::noop) noexcept;
 
    [[deprecated("Use require(Requirement)")]]
    bool require(bool condition, const std::string& msg,
                 RequirementResult::DebugInfo debug_info = RequirementResult::DebugInfo{});
    [[deprecated("Use require(Requirement)")]]
    bool require(bool condition, RequirementResult::DebugInfo debug_info = RequirementResult::DebugInfo{});
 
    template <exprs::Operator Op>
    bool require(const Requirement<Op>& req, RequirementResult::DebugInfo debug_info = RequirementResult::DebugInfo{});
 
    TestResult finalize();
 
 
    std::string_view get_name() const;
 
    void restart_program();
 
    // Low-level exececutor of an arbitrary syscall
    Result<SyscallRecord> exec_syscall(u64 sys_nr, std::array<std::uint64_t, 6> args);
 
    std::string get_stdout();
 
    std::string get_full_stdout();
 
    std::size_t flush_stdin();
 
    const std::vector<SyscallRecord>& get_syscall_records() const;
 
    RegistersState get_registers() const;
 
    void send_stdin(const std::string& input);
 
    template <typename T>
    AsmSymbol<T> find_symbol(std::string_view name);
 
    template <std::size_t NumBytes>
    AsmBuffer<NumBytes> create_buffer();
 
    template <typename Func>
    AsmFunction<Func> find_function(std::string name);
 
    RunResult run();
 
private:
    bool require_impl(bool condition, const std::string& description,
                      const std::optional<exprs::ExpressionRepr>& expression_repr,
                      const RequirementResult::DebugInfo& debug_info);
 
    TestBase* associated_test_;
    Program prog_;
 
    TestResult result_;
 
    // ########### Callbacks
 
    std::function<void(const RequirementResult&)> on_requirement_;
};
 
template <exprs::Operator Op>
bool TestContext::require(const Requirement<Op>& req, RequirementResult::DebugInfo debug_info) {
    return require_impl(static_cast<bool>(req.get_res()), req.get_description(), req.get_expr_repr(), debug_info);
}
 
template <std::size_t NumBytes>
AsmBuffer<NumBytes> TestContext::create_buffer() {
    AsmBuffer<NumBytes> buffer{prog_};
 
    return buffer;
}
 
template <typename T>
AsmSymbol<T> TestContext::find_symbol(std::string_view name) {
    static_assert(MemoryReadSupported<T>, "Specified type does not have supported memory read operation! See docs.");
 
    auto symbol = prog_.get_symtab().find(name);
 
    if (!symbol) {
        LOG_DEBUG("Could not resolve symbol {:?}", name);
        return {prog_, std::string{name}, ErrorKind::UnresolvedSymbol};
    }
 
    return {prog_, std::string{name}, symbol->address};
}
 
template <typename Func>
AsmFunction<Func> TestContext::find_function(std::string name) {
    auto loc = prog_.get_symtab().find(name);
 
    if (!loc) {
        return {prog_, std::move(name), ErrorKind::UnresolvedSymbol};
    }
 
    return {prog_, std::move(name), loc->address};
}
 
} // namespace asmgrader