lib/test_backend.h

/*
 * SPDX-FileCopyrightText: 2022 The P4 Language Consortium
 *
 * SPDX-License-Identifier: Apache-2.0
 */
 
#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 P4::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 P4::P4Tools::P4Testgen
 
#endif /* BACKENDS_P4TOOLS_MODULES_TESTGEN_LIB_TEST_BACKEND_H_ */