test/gtest_utils.h

#ifndef BACKENDS_P4TOOLS_MODULES_TESTGEN_TEST_GTEST_UTILS_H_
#define BACKENDS_P4TOOLS_MODULES_TESTGEN_TEST_GTEST_UTILS_H_
 
#include <gtest/gtest.h>
 
#include <memory>
#include <optional>
#include <string>
 
#include "frontends/common/options.h"
#include "ir/ir.h"
#include "lib/compile_context.h"
 
#include "backends/p4tools/modules/testgen/core/target.h"
#include "backends/p4tools/modules/testgen/register.h"
#include "backends/p4tools/modules/testgen/toolname.h"
 
namespace P4::P4Tools::Test {
 
class P4ToolsTestCase {
 public:
    static std::optional<const P4ToolsTestCase> create(std::string deviceName, std::string archName,
                                                       CompilerOptions::FrontendVersion langVersion,
                                                       const std::string &source);
 
    static std::optional<const P4ToolsTestCase> create_14(std::string deviceName,
                                                          std::string archName,
                                                          const std::string &source);
 
    static std::optional<const P4ToolsTestCase> create_16(std::string deviceName,
                                                          std::string archName,
                                                          const std::string &source);
 
    explicit P4ToolsTestCase(const P4Tools::CompilerResult &compilerResults);
 
    [[nodiscard]] const IR::P4Program &getProgram() const;
 
    [[nodiscard]] const P4Tools::CompilerResult &getCompilerResult() const;
 
 private:
    std::reference_wrapper<const P4Tools::CompilerResult> compilerResults;
 
    static void ensureInit();
};
 
class P4TestgenTest : public testing::Test {
 public:
    [[nodiscard]] static std::unique_ptr<AutoCompileContext> SetUp(std::string_view target,
                                                                   std::string_view archName) {
        P4Tools::P4Testgen::registerTestgenTargets();
        auto ctxOpt = P4Testgen::TestgenTarget::initializeTarget(P4Tools::P4Testgen::TOOL_NAME,
                                                                 target, archName);
 
        if (!ctxOpt.has_value()) {
            return nullptr;
        }
        return std::make_unique<AutoCompileContext>(ctxOpt.value());
    }
};
 
class SymbolicConverter : public Transform {
 public:
    const IR::SymbolicVariable *preorder(IR::Member *member) override;
};
 
}  // namespace P4::P4Tools::Test
 
#endif /* BACKENDS_P4TOOLS_MODULES_TESTGEN_TEST_GTEST_UTILS_H_ */