createOpGraphFromConfig_tests.cpp

Go to the documentation of this file.

/*******************************************************************************
 * The software programs comprising "CGRA-ME" and the documentation provided
 * with them are copyright by its authors and the University of Toronto. Only
 * non-commercial, not-for-profit use of this software is permitted without ex-
 * plicit permission. This software is provided "as is" with no warranties or
 * guarantees of support. See the LICENCE for more details. You should have re-
 * ceived a copy of the full licence along with this software. If not, see
 * <http://cgra-me.ece.utoronto.ca/license/>.
 ******************************************************************************/
 
#include <CGRA/OpGraphProcedures.h>
#include <CGRA/utility/ConfigGraph.h>
 
#include "testutils/OpGraphsForTesting.hpp"
 
#include <catch2/catch.hpp>
 
namespace {
 
struct CreateOpGraphFromConfigTest {
    std::string input_description;
    bool expect_to_parse;
    ConfigGraph input;
    OpGraph expected;
};
 
template<typename Test>
void run_createOpGraphFromConfig_test(const Test& test);
 
} // end anon namespace
 
TEST_CASE("createOpGraphFromConfig Tests") {
    const CreateOpGraphFromConfigTest tests[] = { // OpGraph is move only...
        { "one op", true,
            []{ // (immediately invoked)
                ConfigGraph cg;
                cg.insert("a", {{"opcode", "add"}});
                return cg;
            }(),
            []{ // (immediately invoked)
                OpGraph og;
                og.insert({"a", 32, OpCode::ADD});
                return finalFixup(std::move(og));
            }(),
        },
        { "a; b", true,
            []{ // (immediately invoked)
                ConfigGraph cg;
                cg.insert("a", {{"opcode","add"}});
                cg.insert("b", {{"opcode","add"}});
                return cg;
            }(),
            []{ // (immediately invoked)
                OpGraph og;
                og.insert({"a", 32, OpCode::ADD});
                og.insert({"b", 32, OpCode::ADD});
                return finalFixup(std::move(og));
            }(),
        },
        { "a->b", true,
            []{ // (immediately invoked)
                ConfigGraph cg;
                cg.link(
                    cg.insert("a", {{"opcode","add"}}).first,
                    cg.insert("b", {{"opcode","add"}}).first,
                    {{"operand",Operands::BINARY_ANY}}
                );
                return cg;
            }(),
            [] {  // (immediately invoked)
                OpGraph og;
                const auto a = og.insert({"a", 32, OpCode::ADD});
                const auto b = og.insert(a, {"b", 32, OpCode::ADD}, Operands::BINARY_ANY).newOp;
                (void)b;
                return finalFixup(std::move(og));
            }(),
        },
        { "const op", true,
            [] {  // (immediately invoked)
                ConfigGraph cg;
                cg.insert("a", {{"opcode", "const"}, {"constVal", "4"}});
                return cg;
            }(),
            [] {  // (immediately invoked)
                OpGraph og;
                og.insert({"a", 32, OpCode::CONST, 4});
                return finalFixup(std::move(og));
            }(),
        },
    };
 
    using std::begin; using std::end;
    const auto& test_it = GENERATE_REF(range((std::ptrdiff_t)0, std::distance(begin(tests), end(tests))));
    run_createOpGraphFromConfig_test(tests[test_it]);
}
 
namespace {
 
template<typename T>
OpGraph do_createOpGraphFromConfig(const T& input) {
    try {
        return createOpGraphFromConfig(input);
    } catch (const std::exception& e) {
        std::ostringstream s;
        s << "Exception when creating from configuration: " << e.what()
          << "\nInput was:\n" << input;
        std::throw_with_nested(std::logic_error(s.str()));
    }
}
 
template<typename Test>
void run_createOpGraphFromConfig_test(const Test& test) {
    GIVEN("A '" << test.input_description << "' configuration") {
        WHEN("Creating an OpGraph from it") {
            THEN("The result should " << (test.expect_to_parse ? "be as expected" : "fail to parse")) {
                if (test.expect_to_parse) {
                    const auto actual = do_createOpGraphFromConfig(test.input);
                    CHECK(actual == test.expected);
                } else {
                    REQUIRE_THROWS(do_createOpGraphFromConfig(test.input));
                }
            }
        }
    }
}
 
}  // end anon namespace