bf_gtest_helpers.h

 
#ifndef BF_GTEST_HELPERS_H_
#define BF_GTEST_HELPERS_H_
 
#include <initializer_list>
#include <iosfwd>
#include <regex>
#include <string>
#include <vector>
 
#include <boost/operators.hpp>
 
#include "lib/compile_context.h"
 
// Forward declarations.
namespace P4 {
class Visitor;
struct Visitor_Context;
namespace IR {
class P4Program;
}  // namespace IR
namespace IR {
namespace BFN {
class Pipe;
}  // namespace BFN
}  // namespace IR
}  // namespace P4
namespace BFN {
class Backend;
}
class MauAsmOutput;
 
namespace P4::Test {
 
namespace Match {
 
std::string trimWhiteSpace(std::string str);
 
std::string trimAnnotations(const std::string &str);
 
enum Flag { Raw = 0, TrimWhiteSpace = 1, TrimAnnotations = 2 };
inline Flag operator|(Flag a, Flag b) {
    return static_cast<Flag>(static_cast<int>(a) | static_cast<int>(b));
}
 
std::string convert_to_regex(const std::string &expr);
 
constexpr size_t failed = std::string::npos;
size_t match_basic(const std::string &expr, const std::string &str, size_t pos = 0,
                   size_t n_pos = std::string::npos);
 
typedef std::vector<std::string> CheckList;
 
struct Result : boost::equality_comparable<Result> {
    bool success;  
    size_t pos;    
    size_t count;  
    std::vector<std::string> matches;
    Result(bool success, size_t pos, size_t count) : success(success), pos(pos), count(count) {}
    Result(bool success, size_t pos, size_t count, std::smatch match)
        : success(success), pos(pos), count(count) {
        for (std::size_t n = 0; n < match.size(); ++n) matches.push_back(match[n]);
    }
    friend bool operator==(const Result &l, const Result &r) {
        return l.success == r.success && l.pos == r.pos && l.count == r.count;
    }
};
 
Result match(const CheckList &exprs, const std::string &str, size_t pos = 0,
             size_t n_pos = std::string::npos, Flag flag = Raw);
 
// 'ends' can be any two differing characters e.g. "AZ".
inline const std::string BraceEnds() { return "{}"; }
inline const std::string ParenEnds() { return "()"; }
inline const std::string SquareEnds() { return "[]"; }
inline const std::string AngleEnds() { return "<>"; }
 
size_t find_next_end(const std::string &str, size_t pos, const std::string &ends);
 
// 'find_next_block' finds the opening & closing ends, where 'pos' is before the opening character.
std::pair<size_t, size_t> find_next_block(const std::string &str, size_t pos,
                                          const std::string &ends);
std::string get_ends(char opening);
 
}  // namespace Match
 
class TestCode {
    // AutoCompileContext adds to the stack a new compilation context for the test to run in.
    AutoCompileContext context;
    const IR::P4Program *program = nullptr;  // Used by frontend and midend passes.
    const IR::BFN::Pipe *pipe = nullptr;     // Used by backend passes.
    BFN::Backend *backend = nullptr;         // Used by extract_asm()
    mutable MauAsmOutput *mauasm = nullptr;  // lazy initialised & used by extract_asm().
 
    Match::Flag flag = Match::TrimWhiteSpace;  // N.B. common to match() & extract_code().
    std::regex marker;  // Optional search string for the block we are interested in.
    std::string ends;   // How our optional block starts and ends.
 
    std::string phv_log_file = {};  // path to phv log file
 
 public:
    const IR::P4Program *get_program() { return program; }
    static std::string any_to_brace() { return "`([^\\{]*\\{)`"; }  // viz ".*{"
    static std::string empty_state() { return "state start {transition accept;}"; }
    static std::string empty_appy() { return "apply {}"; }
 
    static std::string min_control_shell();  // See cpp file for the code.
    static std::string min_control_shell_marker() { return "control testingress" + any_to_brace(); }
 
    static std::string tofino_shell();  // See cpp file for the code.
    static std::string tofino_shell_parser_marker() {
        return "parser ingress_parser" + any_to_brace();
    }
    static std::string tofino_shell_control_marker() {
        return "control ingress_control" + any_to_brace();
    }
    static std::string tofino_shell_deparser_marker() {
        return "control ingress_deparser" + any_to_brace();
    }
    // TODO would a smaller test program (as used in test_bf_gtest_helpers.cpp) be of general value?
 
    enum class Hdr {
        None,       // You need to provide the 'package' - see min_control_shell().
        CoreP4,     // The core.p4 package.
        TofinoMin,  // For building an empty tofino_shell() - add only what you need.
        Tofino1arch,
        Tofino2arch,  // The regular header files
        V1model_2018,
        V1model_2020
    };  // The regular header files.
 
    TestCode(Hdr header,        
             std::string code,  
             const std::initializer_list<std::string> &insertion = {},  
             const std::string &blockMarker = "",                       
             const std::initializer_list<std::string> &options = {});
 
    static TestCode TestControlBlock(const std::string &defines, const std::string &block,
                                     Hdr header = Hdr::None) {
        std::initializer_list<std::string> insert = {defines, block};
        return TestCode(header, min_control_shell(), insert, min_control_shell_marker());
    }
 
    void flags(Match::Flag f) { flag = f; }
 
    void set_phv_log_file(std::string path) { phv_log_file = path; }
 
    bool apply_pass(Visitor &pass, const Visitor_Context *context = nullptr);
    bool apply_pass(Visitor *pass, const Visitor_Context *context = nullptr) {
        return apply_pass(*pass, context);
    }
    enum class Pass {
        FullFrontend,          
        FullMidend,            
        ConverterToBackend,    
        ThreadLocalInstances,  
        FullBackend,           
        PhvLogging
    };  
    bool apply_pass(Pass pass);
 
    bool CreateBackend() {
        return apply_pass(Pass::FullFrontend) && apply_pass(Pass::FullMidend) &&
               apply_pass(Pass::ConverterToBackend);
    }
    bool CreateBlockThreadLocalInstances() {
        return CreateBackend() && apply_pass(Pass::ThreadLocalInstances);
    }
 
    enum class CodeBlock {
        P4Code,  // P4Code combines with `blockMarker`.
        PhvAsm,
        MauAsm,  // Ingress & Egress.
        HdrAsm,  // Ingress & Egress.
        ParserIAsm,
        DeparserIAsm,  // Ingress.
        ParserEAsm,
        DeparserEAsm
    };  // Egress.
 
    Match::Result match(CodeBlock blk_type, const Match::CheckList &exprs) const;
    Match::Result match(const Match::CheckList &exprs) const {
        return match(CodeBlock::P4Code, exprs);
    }
 
    std::string extract_code(CodeBlock blk_type, size_t pos = 0) const;
    std::string extract_code(size_t pos = 0) const { return extract_code(CodeBlock::P4Code, pos); }
 
    std::string get_field_container(const std::string &field, const std::string &str,
                                    int idx = 0) const;
 
    friend std::ostream &operator<<(std::ostream &out, const TestCode &tc) {
        return out << tc.extract_code(CodeBlock::P4Code, 0);
    }
 
 private:
    std::string extract_p4() const;
    std::string extract_asm(CodeBlock blk_type) const;
};
 
}  // namespace P4::Test
 
#endif /* BF_GTEST_HELPERS_H_ */