test_framework.h

#ifndef BACKENDS_P4TOOLS_MODULES_TESTGEN_LIB_TEST_FRAMEWORK_H_
#define BACKENDS_P4TOOLS_MODULES_TESTGEN_LIB_TEST_FRAMEWORK_H_
 
#include <cstddef>
#include <filesystem>
#include <functional>
#include <iosfwd>
#include <map>
#include <optional>
#include <string>
#include <utility>
 
#include <inja/inja.hpp>
 
#include "backends/p4tools/common/lib/format_int.h"
#include "backends/p4tools/common/lib/trace_event.h"
#include "lib/castable.h"
#include "lib/cstring.h"
 
#include "backends/p4tools/modules/testgen/lib/test_backend_configuration.h"
#include "backends/p4tools/modules/testgen/lib/test_object.h"
#include "backends/p4tools/modules/testgen/lib/test_spec.h"
 
namespace P4::P4Tools::P4Testgen {
 
using namespace P4::literals;

struct AbstractTest : ICastable {};
using AbstractTestReference = const AbstractTest *;
using AbstractTestReferenceOrError = std::optional<AbstractTestReference>;
using AbstractTestList = std::vector<AbstractTestReference>;

template <class ConcreteTest,
          typename = std::enable_if_t<std::is_base_of_v<AbstractTest, ConcreteTest>>>
std::vector<const ConcreteTest *> convertAbstractTestsToConcreteTests(
    const P4Tools::P4Testgen::AbstractTestList &testList) {
    std::vector<const ConcreteTest *> result;
    std::transform(testList.begin(), testList.end(), std::back_inserter(result),
                   [](AbstractTestReference test) { return test->checkedTo<ConcreteTest>(); });
    return result;
}

using OptionalFilePath = std::optional<std::filesystem::path>;

class TestFramework {
 private:
    std::reference_wrapper<const TestBackendConfiguration> testBackendConfiguration;
 
 protected:
    explicit TestFramework(const TestBackendConfiguration &testBackendConfiguration);

    static inja::json getTrace(const TestSpec *testSpec) {
        inja::json traceList = inja::json::array();
        const auto *traces = testSpec->getTraces();
        if (traces != nullptr) {
            for (const auto &trace : *traces) {
                std::stringstream ss;
                ss << trace;
                traceList.push_back(ss.str());
            }
        }
        return traceList;
    }

    template <class ProfileType, class SelectorType>
    static void checkForTableActionProfile(inja::json &tblJson, std::map<cstring, cstring> &apAsMap,
                                           const TableConfig *tblConfig) {
        const auto *apObject = tblConfig->getProperty("action_profile"_cs, false);
        if (apObject != nullptr) {
            const auto *actionProfile = apObject->checkedTo<ProfileType>();
            tblJson["has_ap"] = true;
            // Check if we have an Action Selector too.
            // TODO: Change this to check in ActionSelector with table
            // property "action_selectors".
            const auto *asObject = tblConfig->getProperty("action_selector"_cs, false);
            if (asObject != nullptr) {
                const auto *actionSelector = asObject->checkedTo<SelectorType>();
                apAsMap[actionProfile->getProfileDecl()->controlPlaneName()] =
                    actionSelector->getSelectorDecl()->controlPlaneName();
                tblJson["has_as"] = true;
            }
        }
    }

    static void checkForDefaultActionOverride(inja::json &tblJson, const TableConfig *tblConfig) {
        const auto *defaultOverrideObj =
            tblConfig->getProperty("overriden_default_action"_cs, false);
        if (defaultOverrideObj != nullptr) {
            const auto *defaultAction = defaultOverrideObj->checkedTo<ActionCall>();
            inja::json a;
            a["action_name"] = defaultAction->getActionName();
            auto const *actionArgs = defaultAction->getArgs();
            inja::json b = inja::json::array();
            for (const auto &actArg : *actionArgs) {
                inja::json j;
                j["param"] = actArg.getActionParamName().c_str();
                j["value"] = formatHexExpr(actArg.getEvaluatedValue());
                b.push_back(j);
            }
            a["act_args"] = b;
            tblJson["default_override"] = a;
        }
    }

    template <class ProfileType>
    static void collectActionProfileDeclarations(const TestSpec *testSpec,
                                                 inja::json &controlPlaneJson,
                                                 const std::map<cstring, cstring> &apAsMap) {
        auto actionProfiles = testSpec->getTestObjectCategory("action_profiles"_cs);
        if (!actionProfiles.empty()) {
            controlPlaneJson["action_profiles"] = inja::json::array();
        }
        for (auto const &testObject : actionProfiles) {
            const auto *const actionProfile = testObject.second->checkedTo<ProfileType>();
            const auto *actions = actionProfile->getActions();
            inja::json j;
            j["profile"] = actionProfile->getProfileDecl()->controlPlaneName();
            j["actions"] = inja::json::array();
            for (size_t idx = 0; idx < actions->size(); ++idx) {
                const auto &action = actions->at(idx);
                auto actionName = action.first;
                auto actionArgs = action.second;
                inja::json a;
                a["action_name"] = actionName;
                a["action_idx"] = std::to_string(idx);
                inja::json b = inja::json::array();
                for (const auto &actArg : actionArgs) {
                    inja::json c;
                    c["param"] = actArg.getActionParamName().c_str();
                    c["value"] = formatHexExpr(actArg.getEvaluatedValue()).c_str();
                    b.push_back(c);
                }
                a["act_args"] = b;
                j["actions"].push_back(a);
            }
            // Look up the selectors associated with the profile.
            if (apAsMap.find(actionProfile->getProfileDecl()->controlPlaneName()) !=
                apAsMap.end()) {
                j["selector"] = apAsMap.at(actionProfile->getProfileDecl()->controlPlaneName());
            }
            controlPlaneJson["action_profiles"].push_back(j);
        }
    }

    [[nodiscard]] const TestBackendConfiguration &getTestBackendConfiguration() const;
 
 public:
    virtual ~TestFramework() = default;

    virtual void writeTestToFile(const TestSpec *spec, cstring selectedBranches, size_t testIdx,
                                 float currentCoverage) = 0;

    virtual AbstractTestReferenceOrError produceTest(const TestSpec *spec, cstring selectedBranches,
                                                     size_t testIdx, float currentCoverage);

    [[nodiscard]] bool isInFileMode() const;
};
 
}  // namespace P4::P4Tools::P4Testgen
 
#endif /* BACKENDS_P4TOOLS_MODULES_TESTGEN_LIB_TEST_FRAMEWORK_H_ */