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/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 <cstddef>
#include <cstdint>
#include <functional>
#include <string>
#include <string_view>
#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;
 
    bool require(bool condition, std::string msg,
                 RequirementResult::DebugInfo debug_info = RequirementResult::DebugInfo{});
    bool require(bool condition, 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:
    TestBase* associated_test_;
    Program prog_;
 
    TestResult result_;
 
    // ########### Callbacks
 
    std::function<void(const RequirementResult&)> on_requirement_;
};
 
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