lib/test_backend.h

#ifndef BACKENDS_P4TOOLS_MODULES_TESTGEN_LIB_TEST_BACKEND_H_
#define BACKENDS_P4TOOLS_MODULES_TESTGEN_LIB_TEST_BACKEND_H_
 
#include <cstdint>
#include <functional>
#include <optional>
#include <vector>
 
#include "backends/p4tools/common/lib/model.h"
#include "backends/p4tools/common/lib/trace_event.h"
#include "ir/ir.h"
 
#include "backends/p4tools/modules/testgen/core/program_info.h"
#include "backends/p4tools/modules/testgen/core/symbolic_executor/symbolic_executor.h"
#include "backends/p4tools/modules/testgen/lib/execution_state.h"
#include "backends/p4tools/modules/testgen/lib/final_state.h"
#include "backends/p4tools/modules/testgen/lib/test_framework.h"
#include "backends/p4tools/modules/testgen/lib/test_spec.h"
#include "backends/p4tools/modules/testgen/options.h"
 
namespace P4Tools::P4Testgen {
 
class TestBackEnd {
 private:
    int64_t testCount = 0;
 
    static const int64_t RESET_THRESHOLD = 10000;
 
    std::reference_wrapper<const ProgramInfo> programInfo;
 
    std::reference_wrapper<const TestBackendConfiguration> testBackendConfiguration;
 
 protected:
    TestFramework *testWriter = nullptr;
 
    SymbolicExecutor &symbex;
 
    int64_t maxTests;
 
    float coverage = 0;
 
    AbstractTestList tests;
 
    explicit TestBackEnd(const ProgramInfo &programInfo,
                         const TestBackendConfiguration &testBackendConfiguration,
                         SymbolicExecutor &symbex);
 
    [[nodiscard]] bool needsToTerminate(int64_t testCount) const;
 
 public:
    TestBackEnd(const TestBackEnd &) = default;
 
    TestBackEnd(TestBackEnd &&) = default;
 
    TestBackEnd &operator=(const TestBackEnd &) = delete;
 
    TestBackEnd &operator=(TestBackEnd &&) = delete;
 
    virtual ~TestBackEnd() = default;
 
    struct TestInfo {
        const IR::Constant *inputPacket;
 
        int inputPort;
 
        const IR::Constant *outputPacket;
 
        int outputPort;
 
        const IR::Constant *packetTaintMask;
 
        const std::vector<std::reference_wrapper<const TraceEvent>> programTraces;
 
        bool packetIsDropped = false;
    };
 
    virtual const TestSpec *createTestSpec(const ExecutionState *executionState,
                                           const Model *finalModel, const TestInfo &testInfo) = 0;
 
    virtual bool printTestInfo(const ExecutionState *executionState, const TestInfo &testInfo,
                               const IR::Expression *outputPortExpr);
 
    [[nodiscard]] std::optional<std::reference_wrapper<const FinalState>> computeConcolicVariables(
        const FinalState &state) const;
 
    virtual TestInfo produceTestInfo(
        const ExecutionState *executionState, const Model *finalModel,
        const IR::Expression *outputPacketExpr, const IR::Expression *outputPortExpr,
        const std::vector<std::reference_wrapper<const TraceEvent>> *programTraces);
 
    virtual bool run(const FinalState &state);
 
    [[nodiscard]] int64_t getTestCount() const;
 
    [[nodiscard]] float getCoverage() const;
 
    [[nodiscard]] const ProgramInfo &getProgramInfo() const;
 
    [[nodiscard]] const TestBackendConfiguration &getTestBackendConfiguration() const;
 
    [[nodiscard]] const AbstractTestList &getTests() const { return tests; }
};
 
}  // namespace P4Tools::P4Testgen
 
#endif /* BACKENDS_P4TOOLS_MODULES_TESTGEN_LIB_TEST_BACKEND_H_ */