lib/test_spec.h

#ifndef BACKENDS_P4TOOLS_MODULES_TESTGEN_LIB_TEST_SPEC_H_
#define BACKENDS_P4TOOLS_MODULES_TESTGEN_LIB_TEST_SPEC_H_
 
#include <functional>
#include <map>
#include <optional>
#include <vector>
 
#include "backends/p4tools/common/lib/model.h"
#include "backends/p4tools/common/lib/trace_event.h"
#include "ir/ir.h"
#include "lib/cstring.h"
 
#include "backends/p4tools/modules/testgen/lib/test_object.h"
 
namespace P4::P4Tools::P4Testgen {
 
 
/* =========================================================================================
 *  Packet
 * ========================================================================================= */
 
class Packet : public TestObject {
 private:
    int port;
 
    const IR::Expression *payload;
 
    const IR::Expression *payloadIgnoreMask;
 
 public:
    Packet(int port, const IR::Expression *payload, const IR::Expression *payloadIgnoreMask);
 
    [[nodiscard]] const Packet *evaluate(const Model &model, bool doComplete) const override;
 
    [[nodiscard]] cstring getObjectName() const override;
 
    [[nodiscard]] int getPort() const;
 
    [[nodiscard]] const IR::Constant *getEvaluatedPayload() const;
 
    [[nodiscard]] const IR::Constant *getEvaluatedPayloadMask() const;
 
    DECLARE_TYPEINFO(Packet, TestObject);
};
 
/* =========================================================================================
 *  Table Test Objects
 * ========================================================================================= */
 
class ActionArg : public TestObject {
 private:
    const IR::Parameter *param;
 
    const IR::Expression *value;
 
 public:
    ActionArg(const IR::Parameter *param, const IR::Expression *value);
 
    [[nodiscard]] const ActionArg *evaluate(const Model &model, bool doComplete) const override;
 
    [[nodiscard]] cstring getObjectName() const override;
 
    [[nodiscard]] const IR::Parameter *getActionParam() const;
 
    [[nodiscard]] cstring getActionParamName() const;
 
    [[nodiscard]] const IR::Constant *getEvaluatedValue() const;
 
    DECLARE_TYPEINFO(ActionArg, TestObject);
};
 
class ActionCall : public TestObject {
 private:
    cstring identifier;
 
    const IR::P4Action *action;
 
    const std::vector<ActionArg> args;
 
 public:
    ActionCall(cstring identifier, const IR::P4Action *action, std::vector<ActionArg> args);
 
    ActionCall(const IR::P4Action *action, std::vector<ActionArg> args);
 
    [[nodiscard]] const ActionCall *evaluate(const Model &model, bool doComplete) const override;
 
    [[nodiscard]] cstring getObjectName() const override;
 
    [[nodiscard]] cstring getActionName() const;
 
    [[nodiscard]] const IR::P4Action *getAction() const;
 
    [[nodiscard]] const std::vector<ActionArg> *getArgs() const;
 
    DECLARE_TYPEINFO(ActionCall, TestObject);
};
 
class TableMatch : public TestObject {
 private:
    const IR::KeyElement *key;
 
 public:
    explicit TableMatch(const IR::KeyElement *key);
 
    [[nodiscard]] const IR::KeyElement *getKey() const;
 
    DECLARE_TYPEINFO(TableMatch, TestObject);
};
 
using TableMatchMap = std::map<cstring, const TableMatch *>;
 
class Ternary : public TableMatch {
 private:
    const IR::Expression *value;
 
    const IR::Expression *mask;
 
 public:
    explicit Ternary(const IR::KeyElement *key, const IR::Expression *value,
                     const IR::Expression *mask);
 
    [[nodiscard]] const Ternary *evaluate(const Model &model, bool doComplete) const override;
 
    [[nodiscard]] cstring getObjectName() const override;
 
    [[nodiscard]] const IR::Constant *getEvaluatedValue() const;
 
    [[nodiscard]] const IR::Constant *getEvaluatedMask() const;
 
    DECLARE_TYPEINFO(Ternary, TableMatch);
};
 
class LPM : public TableMatch {
 private:
    const IR::Expression *value;
 
    const IR::Expression *prefixLength;
 
 public:
    explicit LPM(const IR::KeyElement *key, const IR::Expression *value,
                 const IR::Expression *prefixLength);
 
    [[nodiscard]] const LPM *evaluate(const Model &model, bool doComplete) const override;
 
    [[nodiscard]] cstring getObjectName() const override;
 
    [[nodiscard]] const IR::Constant *getEvaluatedValue() const;
 
    [[nodiscard]] const IR::Constant *getEvaluatedPrefixLength() const;
 
    DECLARE_TYPEINFO(LPM, TableMatch);
};
 
class Exact : public TableMatch {
 private:
    const IR::Expression *value;
 
 public:
    explicit Exact(const IR::KeyElement *key, const IR::Expression *value);
 
    [[nodiscard]] const Exact *evaluate(const Model &model, bool doComplete) const override;
 
    [[nodiscard]] cstring getObjectName() const override;
 
    [[nodiscard]] const IR::Constant *getEvaluatedValue() const;
 
    DECLARE_TYPEINFO(Exact, TableMatch);
};
 
class TableRule : public TestObject {
 private:
    const TableMatchMap matches;
 
    int priority;
    const ActionCall action;
    int ttl;
 
 public:
    TableRule(TableMatchMap matches, int priority, ActionCall action, int ttl);
 
    [[nodiscard]] const TableRule *evaluate(const Model &model, bool doComplete) const override;
 
    [[nodiscard]] cstring getObjectName() const override;
 
    [[nodiscard]] const TableMatchMap *getMatches() const;
 
    [[nodiscard]] int getPriority() const;
 
    [[nodiscard]] const ActionCall *getActionCall() const;
 
    [[nodiscard]] int getTTL() const;
 
    DECLARE_TYPEINFO(TableRule, TestObject);
};
 
class TableConfig : public TestObject {
 private:
    const IR::P4Table *table;
 
    const std::vector<TableRule> rules;
 
    TestObjectMap tableProperties;
 
 public:
    explicit TableConfig(const IR::P4Table *table, std::vector<TableRule> rules);
 
    explicit TableConfig(const IR::P4Table *table, std::vector<TableRule> rules,
                         TestObjectMap tableProperties);
 
    [[nodiscard]] const IR::P4Table *getTable() const;
 
    [[nodiscard]] cstring getObjectName() const override;
 
    [[nodiscard]] const TableConfig *evaluate(const Model &model, bool doComplete) const override;
 
    [[nodiscard]] const std::vector<TableRule> *getRules() const;
 
    [[nodiscard]] const TestObjectMap *getProperties() const;
 
    [[nodiscard]] const TestObject *getProperty(cstring propertyName, bool checked) const;
 
    void addTableProperty(cstring propertyName, const TestObject *property);
 
    DECLARE_TYPEINFO(TableConfig, TestObject);
};
 
/* =========================================================================================
 * Test Specification
 * ========================================================================================= */
 
class TestSpec {
 private:
    const Packet ingressPacket;
 
    const std::optional<Packet> egressPacket;
 
    const std::vector<std::reference_wrapper<const TraceEvent>> traces;
 
    std::map<cstring, TestObjectMap> testObjects;
 
 public:
    TestSpec(Packet ingressPacket, std::optional<Packet> egressPacket,
             std::vector<std::reference_wrapper<const TraceEvent>> traces);
 
    void addTestObject(cstring category, cstring objectLabel, const TestObject *object);
 
    [[nodiscard]] const TestObject *getTestObject(cstring category, cstring objectLabel,
                                                  bool checked) const;
 
    template <class T>
    [[nodiscard]] auto *getTestObject(cstring category, cstring objectLabel, bool checked) const {
        const auto *testObject = getTestObject(category, objectLabel, checked);
        return testObject->checkedTo<T>();
    }
 
    [[nodiscard]] TestObjectMap getTestObjectCategory(cstring category) const;
 
    [[nodiscard]] const Packet *getIngressPacket() const;
 
    [[nodiscard]] const std::map<cstring, const TableConfig> *getTables() const;
 
    [[nodiscard]] std::optional<const Packet *> getEgressPacket() const;
 
    [[nodiscard]] const std::vector<std::reference_wrapper<const TraceEvent>> *getTraces() const;
 
    static constexpr int NO_PRIORITY = -1;
    static constexpr int LOW_PRIORITY = 1;
    static constexpr int HIGH_PRIORITY = 100;
    static constexpr int TTL = 0;
};
 
}  // namespace P4::P4Tools::P4Testgen
 
#endif /* BACKENDS_P4TOOLS_MODULES_TESTGEN_LIB_TEST_SPEC_H_ */