From 7c1e0420c6e8a358ea8ef273e20c7df241724bbe Mon Sep 17 00:00:00 2001 From: Bartek Kryza Date: Thu, 16 May 2024 21:58:45 +0200 Subject: [PATCH] Refactoring sequence diagrams test cases (#266) --- .../json/class_diagram_generator.cc | 2 +- .../json/sequence_diagram_generator.cc | 10 + tests/t20001/test_case.h | 63 +- tests/t20002/test_case.h | 30 +- tests/t20003/test_case.h | 85 +-- tests/t20004/test_case.h | 167 +++--- tests/t20005/test_case.h | 89 +-- tests/t20006/test_case.h | 224 +++---- tests/t20007/test_case.h | 114 ++-- tests/t20008/test_case.h | 143 ++--- tests/t20009/test_case.h | 121 ++-- tests/t20010/test_case.h | 115 ++-- tests/t20011/test_case.h | 24 +- tests/t20012/test_case.h | 56 +- tests/t20013/test_case.h | 25 +- tests/t20014/test_case.h | 26 +- tests/t20015/test_case.h | 105 ++-- tests/t20016/test_case.h | 97 ++-- tests/t20017/test_case.h | 28 +- tests/t20018/test_case.h | 147 ++--- tests/t20019/test_case.h | 25 +- tests/t20020/test_case.h | 160 ++--- tests/t20021/test_case.h | 32 +- tests/t20022/test_case.h | 77 +-- tests/t20023/test_case.h | 92 +-- tests/t20024/test_case.h | 30 +- tests/t20025/test_case.h | 23 +- tests/t20026/test_case.h | 22 +- tests/t20027/test_case.h | 22 +- tests/t20028/test_case.h | 24 +- tests/t20029/test_case.h | 249 ++++---- tests/t20030/test_case.h | 126 ++-- tests/t20031/test_case.h | 26 +- tests/t20032/test_case.h | 33 +- tests/t20033/test_case.h | 106 ++-- tests/t20034/test_case.h | 158 +++-- tests/t20035/test_case.h | 80 +-- tests/t20036/test_case.h | 149 +++-- tests/t20037/test_case.h | 96 +-- tests/t20038/test_case.h | 172 +++--- tests/t20039/test_case.h | 28 +- tests/t20040/test_case.h | 121 ++-- tests/t20041/test_case.h | 120 ++-- tests/t20042/test_case.h | 88 +-- tests/t20043/test_case.h | 26 +- tests/t20044/test_case.h | 43 +- tests/t20045/test_case.h | 26 +- tests/test_cases.cc | 9 +- tests/test_cases.h | 549 +++++++++++++++++- 49 files changed, 2807 insertions(+), 1576 deletions(-) diff --git a/src/class_diagram/generators/json/class_diagram_generator.cc b/src/class_diagram/generators/json/class_diagram_generator.cc index 4fabe622..f8cb28d5 100644 --- a/src/class_diagram/generators/json/class_diagram_generator.cc +++ b/src/class_diagram/generators/json/class_diagram_generator.cc @@ -248,7 +248,7 @@ void generator::generate(const class_ &c, nlohmann::json &parent) const { nlohmann::json object = c; - // Perform config dependent postprocessing on generated class; + // Perform config dependent postprocessing on generated class if (!config().generate_fully_qualified_name()) object["display_name"] = common::generators::json::render_name(c.full_name_no_ns()); diff --git a/src/sequence_diagram/generators/json/sequence_diagram_generator.cc b/src/sequence_diagram/generators/json/sequence_diagram_generator.cc index 3c0bdfec..8c17daf9 100644 --- a/src/sequence_diagram/generators/json/sequence_diagram_generator.cc +++ b/src/sequence_diagram/generators/json/sequence_diagram_generator.cc @@ -286,6 +286,8 @@ void generator::process_call_message( else LOG_DBG("Skipping activity {} --> {} - missing sequence {}", m.from(), m.to(), m.to()); + + visited.pop_back(); } void generator::process_while_message(const message &m) const @@ -816,6 +818,14 @@ void generator::generate_diagram(nlohmann::json &parent) const } } + // Perform config dependent postprocessing on generated participants + for (auto &p : json_["participants"]) { + if (p.contains("display_name")) { + p["display_name"] = + config().simplify_template_type(p["display_name"]); + } + } + parent["participants"] = json_["participants"]; } } // namespace clanguml::sequence_diagram::generators::json diff --git a/tests/t20001/test_case.h b/tests/t20001/test_case.h index f06f150d..ed29917d 100644 --- a/tests/t20001/test_case.h +++ b/tests/t20001/test_case.h @@ -1,5 +1,5 @@ /** - * tests/t20001/test_case.cc + * tests/t20001/test_case.h * * Copyright (c) 2021-2024 Bartek Kryza * @@ -16,18 +16,66 @@ * limitations under the License. */ -TEST_CASE("t20001", "[test-case][sequence]") +TEST_CASE("t20001") { - auto [config, db] = load_config("t20001"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20001_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20001", "t20001_sequence"); - REQUIRE(diagram->name == "t20001_sequence"); + CHECK_SEQUENCE_DIAGRAM( + config, diagram, *model, + [](const auto &src) { + REQUIRE(HasTitle(src, "Basic sequence diagram example")); - auto model = generate_sequence_diagram(*db, diagram); + REQUIRE(MessageOrder(src, + { + // + {"tmain()", "A", "A()"}, // + {"tmain()", "B", "B(A &)"}, // - REQUIRE(model->name() == "t20001_sequence"); + {"tmain()", "A", "add(int,int)"}, // + {"tmain()", "B", "wrap_add3(int,int,int)"}, // + {"B", "A", "add3(int,int,int)"}, // + {"A", "A", "add(int,int)"}, // + {"A", "A", "log_result(int)", Static{}}, // + {"B", "A", "log_result(int)", Static{}} // + })); + + REQUIRE(!HasMessage(src, {"A", {"detail", "C"}, "add(int,int)"})); + + REQUIRE(HasComment(src, "t20001 test diagram of type sequence")); + + REQUIRE(HasMessageComment(src, "tmain()", "Just add 2 numbers")); + + REQUIRE(HasMessageComment(src, "tmain()", "And now add another 2")); + }, + [](const json_t &src) { + const auto &A = get_participant(src.src, "A"); + + CHECK(A.has_value()); + + CHECK(A.value()["type"] == "class"); + CHECK(A.value()["name"] == "A"); + CHECK(A.value()["display_name"] == "A"); + CHECK(A.value()["namespace"] == "clanguml::t20001"); + CHECK(A.value()["source_location"]["file"] == "t20001.cc"); + CHECK(A.value()["source_location"]["line"] == 13); + + const auto &tmain = get_participant(src.src, "tmain()"); + + CHECK(tmain.has_value()); + + CHECK(tmain.value()["type"] == "function"); + CHECK(tmain.value()["name"] == "tmain"); + CHECK(tmain.value()["display_name"] == "tmain()"); + CHECK(tmain.value()["namespace"] == "clanguml::t20001"); + CHECK(tmain.value()["source_location"]["file"] == "t20001.cc"); + CHECK(tmain.value()["source_location"]["line"] == 61); + }); + + /* { auto src = generate_sequence_puml(diagram, *model); AliasMatcher _A(src); @@ -118,4 +166,5 @@ TEST_CASE("t20001", "[test-case][sequence]") save_mermaid(config.output_directory(), diagram->name + ".mmd", src); } + */ } diff --git a/tests/t20002/test_case.h b/tests/t20002/test_case.h index 65b08719..bc0f8034 100644 --- a/tests/t20002/test_case.h +++ b/tests/t20002/test_case.h @@ -1,5 +1,5 @@ /** - * tests/t20002/test_case.cc + * tests/t20002/test_case.h * * Copyright (c) 2021-2024 Bartek Kryza * @@ -16,18 +16,28 @@ * limitations under the License. */ -TEST_CASE("t20002", "[test-case][sequence]") +TEST_CASE("t20002") { - auto [config, db] = load_config("t20002"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20002_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20002", "t20002_sequence"); - REQUIRE(diagram->name == "t20002_sequence"); - - auto model = generate_sequence_diagram(*db, diagram); - - REQUIRE(model->name() == "t20002_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(IsFunctionParticipant(src, "m1()")); + REQUIRE(IsFunctionParticipant(src, "m2()")); + REQUIRE(IsFunctionParticipant(src, "m3()")); + REQUIRE(IsFunctionParticipant(src, "m4()")); + REQUIRE(MessageOrder(src, + { + // + {"m1()", "m2()", ""}, // + {"m2()", "m3()", ""}, // + {"m3()", "m4()", ""} // + })); + }); + /* { auto src = generate_sequence_puml(diagram, *model); AliasMatcher _A(src); @@ -72,5 +82,5 @@ TEST_CASE("t20002", "[test-case][sequence]") REQUIRE_THAT(src, HasCall(_A("m3()"), _A("m4()"), "")); save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + }*/ } diff --git a/tests/t20003/test_case.h b/tests/t20003/test_case.h index 6d8fbe3c..ab08e227 100644 --- a/tests/t20003/test_case.h +++ b/tests/t20003/test_case.h @@ -1,5 +1,5 @@ /** - * tests/t20003/test_case.cc + * tests/t20003/test_case.h * * Copyright (c) 2021-2024 Bartek Kryza * @@ -16,56 +16,67 @@ * limitations under the License. */ -TEST_CASE("t20003", "[test-case][sequence]") +TEST_CASE("t20003") { - auto [config, db] = load_config("t20003"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20003_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20003", "t20003_sequence"); - REQUIRE(diagram->name == "t20003_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(IsFunctionTemplateParticipant(src, "m1(T)")); + REQUIRE(IsFunctionTemplateParticipant(src, "m2(T)")); + REQUIRE(IsFunctionTemplateParticipant(src, "m3(T)")); + REQUIRE(IsFunctionTemplateParticipant(src, "m4(T)")); - auto model = generate_sequence_diagram(*db, diagram); + REQUIRE(MessageOrder(src, + { + // + {"m1(T)", "m2(T)", ""}, // + {"m2(T)", "m3(T)", ""}, // + {"m3(T)", "m4(T)", ""} // + })); + }); + /* + { + auto src = generate_sequence_puml(diagram, *model); + AliasMatcher _A(src); - REQUIRE(model->name() == "t20003_sequence"); + REQUIRE_THAT(src, StartsWith("@startuml")); + REQUIRE_THAT(src, EndsWith("@enduml\n")); - { - auto src = generate_sequence_puml(diagram, *model); - AliasMatcher _A(src); + REQUIRE_THAT(src, HasCall(_A("m1(T)"), _A("m2(T)"), "")); + REQUIRE_THAT(src, HasCall(_A("m2(T)"), _A("m3(T)"), "")); + REQUIRE_THAT(src, HasCall(_A("m3(T)"), _A("m4(T)"), "")); - REQUIRE_THAT(src, StartsWith("@startuml")); - REQUIRE_THAT(src, EndsWith("@enduml\n")); + save_puml(config.output_directory(), diagram->name + ".puml", src); + } - REQUIRE_THAT(src, HasCall(_A("m1(T)"), _A("m2(T)"), "")); - REQUIRE_THAT(src, HasCall(_A("m2(T)"), _A("m3(T)"), "")); - REQUIRE_THAT(src, HasCall(_A("m3(T)"), _A("m4(T)"), "")); + { + auto j = generate_sequence_json(diagram, *model); - save_puml(config.output_directory(), diagram->name + ".puml", src); - } + using namespace json; - { - auto j = generate_sequence_json(diagram, *model); + std::vector messages = {FindMessage(j, "m1(T)", "m2(T)", + ""), FindMessage(j, "m2(T)", "m3(T)", ""), FindMessage(j, + "m3(T)", "m4(T)", "")}; - using namespace json; + REQUIRE(std::is_sorted(messages.begin(), messages.end())); - std::vector messages = {FindMessage(j, "m1(T)", "m2(T)", ""), - FindMessage(j, "m2(T)", "m3(T)", ""), - FindMessage(j, "m3(T)", "m4(T)", "")}; + save_json(config.output_directory(), diagram->name + ".json", j); + } - REQUIRE(std::is_sorted(messages.begin(), messages.end())); + { + auto src = generate_sequence_mermaid(diagram, *model); - save_json(config.output_directory(), diagram->name + ".json", j); - } + mermaid::SequenceDiagramAliasMatcher _A(src); + using mermaid::HasCall; - { - auto src = generate_sequence_mermaid(diagram, *model); + REQUIRE_THAT(src, HasCall(_A("m1(T)"), _A("m2(T)"), "")); + REQUIRE_THAT(src, HasCall(_A("m2(T)"), _A("m3(T)"), "")); + REQUIRE_THAT(src, HasCall(_A("m3(T)"), _A("m4(T)"), "")); - mermaid::SequenceDiagramAliasMatcher _A(src); - using mermaid::HasCall; - - REQUIRE_THAT(src, HasCall(_A("m1(T)"), _A("m2(T)"), "")); - REQUIRE_THAT(src, HasCall(_A("m2(T)"), _A("m3(T)"), "")); - REQUIRE_THAT(src, HasCall(_A("m3(T)"), _A("m4(T)"), "")); - - save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + save_mermaid(config.output_directory(), diagram->name + ".mmd", + src); + }*/ } diff --git a/tests/t20004/test_case.h b/tests/t20004/test_case.h index 67b37ed9..cb87263a 100644 --- a/tests/t20004/test_case.h +++ b/tests/t20004/test_case.h @@ -16,102 +16,115 @@ * limitations under the License. */ -TEST_CASE("t20004", "[test-case][sequence]") +TEST_CASE("t20004") { - auto [config, db] = load_config("t20004"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20004_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20004", "t20004_sequence"); - REQUIRE(diagram->name == "t20004_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"main()", "m1(float)", ""}, // + {"main()", "m1(unsigned long)", ""}, // + {"m1(unsigned long)", + "m4(unsigned long)", ""}, // + {"main()", "m1(std::string)", ""}, // + {"m1(std::string)", "m2(std::string)", + ""}, // + {"main()", "m1(int)", ""}, // + {"m1(int)", "m2(int)", ""}, // + {"m2(int)", "m3(int)", ""}, // + {"m3(int)", "m4(int)", ""} // + })); - auto model = generate_sequence_diagram(*db, diagram); + REQUIRE(!HasMessage(src, {"m1(float)", "m1(float)", ""})); + }); + /* + { + auto src = generate_sequence_puml(diagram, *model); + AliasMatcher _A(src); - REQUIRE(model->name() == "t20004_sequence"); + REQUIRE_THAT(src, StartsWith("@startuml")); + REQUIRE_THAT(src, HasCall(_A("main()"), _A("m1(float)"), + "")); + REQUIRE_THAT( src, !HasCall(_A("m1(float)"), + _A("m1(float)"), "")); + REQUIRE_THAT( src, + !HasCall(_A("m1(float)"), _A("m1(float)"), "")); - { - auto src = generate_sequence_puml(diagram, *model); - AliasMatcher _A(src); + REQUIRE_THAT(src, + HasCall(_A("main()"), _A("m1(unsigned long)"), + "")); + REQUIRE_THAT(src, HasCall(_A("m1(unsigned long)"), + _A("m4(unsigned long)"), "")); - REQUIRE_THAT(src, StartsWith("@startuml")); - REQUIRE_THAT(src, HasCall(_A("main()"), _A("m1(float)"), "")); - REQUIRE_THAT( - src, !HasCall(_A("m1(float)"), _A("m1(float)"), "")); - REQUIRE_THAT( - src, !HasCall(_A("m1(float)"), _A("m1(float)"), "")); + REQUIRE_THAT( + src, HasCall(_A("main()"), _A("m1(std::string)"), + "")); REQUIRE_THAT(src, HasCall(_A("m1(std::string)"), + _A("m2(std::string)"), "")); - REQUIRE_THAT(src, - HasCall(_A("main()"), _A("m1(unsigned long)"), "")); - REQUIRE_THAT(src, - HasCall(_A("m1(unsigned long)"), - _A("m4(unsigned long)"), "")); + REQUIRE_THAT(src, HasCall(_A("main()"), _A("m1(int)"), "")); + REQUIRE_THAT(src, HasCall(_A("m1(int)"), _A("m2(int)"), + "")); REQUIRE_THAT(src, HasCall(_A("m2(int)"), _A("m3(int)"), + "")); REQUIRE_THAT(src, HasCall(_A("m3(int)"), _A("m4(int)"), + "")); REQUIRE_THAT(src, EndsWith("@enduml\n")); - REQUIRE_THAT( - src, HasCall(_A("main()"), _A("m1(std::string)"), "")); - REQUIRE_THAT(src, - HasCall(_A("m1(std::string)"), - _A("m2(std::string)"), "")); + save_puml(config.output_directory(), diagram->name + ".puml", src); + } - REQUIRE_THAT(src, HasCall(_A("main()"), _A("m1(int)"), "")); - REQUIRE_THAT(src, HasCall(_A("m1(int)"), _A("m2(int)"), "")); - REQUIRE_THAT(src, HasCall(_A("m2(int)"), _A("m3(int)"), "")); - REQUIRE_THAT(src, HasCall(_A("m3(int)"), _A("m4(int)"), "")); - REQUIRE_THAT(src, EndsWith("@enduml\n")); + { + auto j = generate_sequence_json(diagram, *model); - save_puml(config.output_directory(), diagram->name + ".puml", src); - } + using namespace json; - { - auto j = generate_sequence_json(diagram, *model); + std::vector messages = { + FindMessage(j, "main()", "m1(float)", ""), + FindMessage(j, "main()", "m1(unsigned long)", + ""), FindMessage(j, "m1(unsigned long)", "m4(unsigned long)", ""), FindMessage(j, "main()", + "m1(std::string)", ""), FindMessage(j, + "m1(std::string)", "m2(std::string)", ""), + FindMessage(j, "main()", "m1(int)", ""), + FindMessage(j, "m1(int)", "m2(int)", ""), + FindMessage(j, "m2(int)", "m3(int)", ""), + FindMessage(j, "m3(int)", "m4(int)", "")}; - using namespace json; + REQUIRE(std::is_sorted(messages.begin(), messages.end())); - std::vector messages = { - FindMessage(j, "main()", "m1(float)", ""), - FindMessage(j, "main()", "m1(unsigned long)", ""), - FindMessage(j, "m1(unsigned long)", - "m4(unsigned long)", ""), - FindMessage(j, "main()", "m1(std::string)", ""), - FindMessage(j, "m1(std::string)", - "m2(std::string)", ""), - FindMessage(j, "main()", "m1(int)", ""), - FindMessage(j, "m1(int)", "m2(int)", ""), - FindMessage(j, "m2(int)", "m3(int)", ""), - FindMessage(j, "m3(int)", "m4(int)", "")}; + save_json(config.output_directory(), diagram->name + ".json", j); + } - REQUIRE(std::is_sorted(messages.begin(), messages.end())); + { + auto src = generate_sequence_mermaid(diagram, *model); - save_json(config.output_directory(), diagram->name + ".json", j); - } + mermaid::SequenceDiagramAliasMatcher _A(src); + using mermaid::HasCall; - { - auto src = generate_sequence_mermaid(diagram, *model); + REQUIRE_THAT(src, HasCall(_A("main()"), _A("m1(float)"), + "")); REQUIRE_THAT( src, !HasCall(_A("m1(float)"), + _A("m1(float)"), "")); REQUIRE_THAT( src, + !HasCall(_A("m1(float)"), _A("m1(float)"), "")); - mermaid::SequenceDiagramAliasMatcher _A(src); - using mermaid::HasCall; + REQUIRE_THAT(src, + HasCall(_A("main()"), _A("m1(unsigned long)"), + "")); REQUIRE_THAT(src, HasCall(_A("m1(unsigned long)"), + _A("m4(unsigned long)"), "")); - REQUIRE_THAT(src, HasCall(_A("main()"), _A("m1(float)"), "")); - REQUIRE_THAT( - src, !HasCall(_A("m1(float)"), _A("m1(float)"), "")); - REQUIRE_THAT( - src, !HasCall(_A("m1(float)"), _A("m1(float)"), "")); + REQUIRE_THAT( + src, HasCall(_A("main()"), _A("m1(std::string)"), + "")); REQUIRE_THAT(src, HasCall(_A("m1(std::string)"), + _A("m2(std::string)"), "")); - REQUIRE_THAT(src, - HasCall(_A("main()"), _A("m1(unsigned long)"), "")); - REQUIRE_THAT(src, - HasCall(_A("m1(unsigned long)"), - _A("m4(unsigned long)"), "")); + REQUIRE_THAT(src, HasCall(_A("main()"), _A("m1(int)"), "")); + REQUIRE_THAT(src, HasCall(_A("m1(int)"), _A("m2(int)"), + "")); REQUIRE_THAT(src, HasCall(_A("m2(int)"), _A("m3(int)"), + "")); REQUIRE_THAT(src, HasCall(_A("m3(int)"), _A("m4(int)"), + "")); - REQUIRE_THAT( - src, HasCall(_A("main()"), _A("m1(std::string)"), "")); - REQUIRE_THAT(src, - HasCall(_A("m1(std::string)"), - _A("m2(std::string)"), "")); - - REQUIRE_THAT(src, HasCall(_A("main()"), _A("m1(int)"), "")); - REQUIRE_THAT(src, HasCall(_A("m1(int)"), _A("m2(int)"), "")); - REQUIRE_THAT(src, HasCall(_A("m2(int)"), _A("m3(int)"), "")); - REQUIRE_THAT(src, HasCall(_A("m3(int)"), _A("m4(int)"), "")); - - save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + save_mermaid(config.output_directory(), diagram->name + ".mmd", + src); + }*/ } \ No newline at end of file diff --git a/tests/t20005/test_case.h b/tests/t20005/test_case.h index 330bbdb1..abc56f9d 100644 --- a/tests/t20005/test_case.h +++ b/tests/t20005/test_case.h @@ -16,60 +16,67 @@ * limitations under the License. */ -TEST_CASE("t20005", "[test-case][sequence]") +TEST_CASE("t20005") { - auto [config, db] = load_config("t20005"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20005_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20005", "t20005_sequence"); - REQUIRE(diagram->name == "t20005_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {Entrypoint{}, "C", "c(T)"}, // + {"C", "B", "b(T)"}, // + {"B", "A", "a(T)"}, // + {Exitpoint{}, "C"} // + })); + }); + /* + { + auto src = generate_sequence_puml(diagram, *model); + AliasMatcher _A(src); - auto model = generate_sequence_diagram(*db, diagram); + REQUIRE_THAT(src, StartsWith("@startuml")); + REQUIRE_THAT(src, EndsWith("@enduml\n")); - REQUIRE(model->name() == "t20005_sequence"); + // Check if all calls exist + REQUIRE_THAT(src, HasEntrypoint(_A("C"), "c(T)")); + REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b(T)")); + REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a(T)")); + REQUIRE_THAT(src, HasExitpoint(_A("C"))); - { - auto src = generate_sequence_puml(diagram, *model); - AliasMatcher _A(src); + save_puml(config.output_directory(), diagram->name + ".puml", src); + } - REQUIRE_THAT(src, StartsWith("@startuml")); - REQUIRE_THAT(src, EndsWith("@enduml\n")); + { + auto j = generate_sequence_json(diagram, *model); - // Check if all calls exist - REQUIRE_THAT(src, HasEntrypoint(_A("C"), "c(T)")); - REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b(T)")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a(T)")); - REQUIRE_THAT(src, HasExitpoint(_A("C"))); + using namespace json; - save_puml(config.output_directory(), diagram->name + ".puml", src); - } + std::vector messages = {FindMessage(j, "C", "B", "b(T)"), + FindMessage(j, "B", "A", "a(T)")}; - { - auto j = generate_sequence_json(diagram, *model); + REQUIRE(std::is_sorted(messages.begin(), messages.end())); - using namespace json; + save_json(config.output_directory(), diagram->name + ".json", j); + } - std::vector messages = {FindMessage(j, "C", "B", "b(T)"), - FindMessage(j, "B", "A", "a(T)")}; + { + auto src = generate_sequence_mermaid(diagram, *model); - REQUIRE(std::is_sorted(messages.begin(), messages.end())); + mermaid::SequenceDiagramAliasMatcher _A(src); + using mermaid::HasCall; + using mermaid::HasEntrypoint; + using mermaid::HasExitpoint; - save_json(config.output_directory(), diagram->name + ".json", j); - } + REQUIRE_THAT(src, HasEntrypoint(_A("C"), "c(T)")); + REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b(T)")); + REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a(T)")); + REQUIRE_THAT(src, HasExitpoint(_A("C"))); - { - auto src = generate_sequence_mermaid(diagram, *model); - - mermaid::SequenceDiagramAliasMatcher _A(src); - using mermaid::HasCall; - using mermaid::HasEntrypoint; - using mermaid::HasExitpoint; - - REQUIRE_THAT(src, HasEntrypoint(_A("C"), "c(T)")); - REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b(T)")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a(T)")); - REQUIRE_THAT(src, HasExitpoint(_A("C"))); - - save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + save_mermaid(config.output_directory(), diagram->name + ".mmd", + src); + }*/ } \ No newline at end of file diff --git a/tests/t20006/test_case.h b/tests/t20006/test_case.h index c825244f..8ac04b5c 100644 --- a/tests/t20006/test_case.h +++ b/tests/t20006/test_case.h @@ -16,132 +16,156 @@ * limitations under the License. */ -TEST_CASE("t20006", "[test-case][sequence]") +TEST_CASE("t20006") { - auto [config, db] = load_config("t20006"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20006_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20006", "t20006_sequence"); - REQUIRE(diagram->name == "t20006_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain()", "B", "b(int)"}, // + {"B", "A", "a1(int)"}, // + {"tmain()", "B", "b(std::string)"}, // + {"B", "A", "a2(std::string)"}, // + {"tmain()", "BB", "bb1(int,int)"}, // + {"BB", "AA", "aa1(int)"}, // + {"tmain()", "BB", "bb2(int,int)"}, // + {"BB", "AA", "aa2(int)"}, // + {"tmain()", "BB", "bb1(int,std::string)"}, // + {"BB", "AA", "aa2(int)"}, // + {"tmain()", "BB", "bb2(int,std::string)"}, // + {"BB", "AA", "aa1(int)"}, // + {"tmain()", "BB", "bb1(int,float)"}, // + {"BB", "BB", "bb2(int,float)"}, // + {"BB", "AA", "aa2(int)"} // - auto model = generate_sequence_diagram(*db, diagram); + })); + }); + /* + { + auto src = generate_sequence_puml(diagram, *model); + AliasMatcher _A(src); - REQUIRE(model->name() == "t20006_sequence"); + REQUIRE_THAT(src, StartsWith("@startuml")); + REQUIRE_THAT(src, EndsWith("@enduml\n")); - { - auto src = generate_sequence_puml(diagram, *model); - AliasMatcher _A(src); + // Check if all calls exist + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b(int)")); + REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a1(int)")); - REQUIRE_THAT(src, StartsWith("@startuml")); - REQUIRE_THAT(src, EndsWith("@enduml\n")); + REQUIRE_THAT(src, + HasCall(_A("tmain()"), _A("B"), "b(std::string)")); + REQUIRE_THAT(src, + HasCall( + _A("B"), _A("A"), + "a2(std::string)")); - // Check if all calls exist - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b(int)")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a1(int)")); + REQUIRE_THAT( + src, HasCall(_A("tmain()"), _A("BB"), "bb1(int,int)")); + REQUIRE_THAT( + src, HasCall(_A("BB"), _A("AA"), "aa1(int)")); - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("B"), "b(std::string)")); - REQUIRE_THAT(src, - HasCall( - _A("B"), _A("A"), "a2(std::string)")); + REQUIRE_THAT( + src, HasCall(_A("tmain()"), _A("BB"), "bb2(int,int)")); + REQUIRE_THAT( + src, HasCall(_A("BB"), _A("AA"), "aa2(int)")); - REQUIRE_THAT( - src, HasCall(_A("tmain()"), _A("BB"), "bb1(int,int)")); - REQUIRE_THAT( - src, HasCall(_A("BB"), _A("AA"), "aa1(int)")); + REQUIRE_THAT(src, + HasCall(_A("tmain()"), _A("BB"), + "bb1(int,std::string)")); + REQUIRE_THAT( + src, HasCall(_A("BB"), _A("AA"), + "aa2(int)")); - REQUIRE_THAT( - src, HasCall(_A("tmain()"), _A("BB"), "bb2(int,int)")); - REQUIRE_THAT( - src, HasCall(_A("BB"), _A("AA"), "aa2(int)")); + REQUIRE_THAT(src, + HasCall(_A("tmain()"), _A("BB"), + "bb2(int,std::string)")); + REQUIRE_THAT( + src, HasCall(_A("BB"), _A("AA"), + "aa1(int)")); - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("BB"), - "bb1(int,std::string)")); - REQUIRE_THAT( - src, HasCall(_A("BB"), _A("AA"), "aa2(int)")); + REQUIRE_THAT( + src, HasCall(_A("tmain()"), _A("BB"), + "bb1(int,float)")); + REQUIRE_THAT(src, HasCall( _A("BB"), + _A("BB"), "bb2(int,float)")); + REQUIRE_THAT( src, + HasCall(_A("BB"), _A("AA"), "aa2(int)")); - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("BB"), - "bb2(int,std::string)")); - REQUIRE_THAT( - src, HasCall(_A("BB"), _A("AA"), "aa1(int)")); + save_puml(config.output_directory(), diagram->name + ".puml", src); + } - REQUIRE_THAT( - src, HasCall(_A("tmain()"), _A("BB"), "bb1(int,float)")); - REQUIRE_THAT(src, - HasCall( - _A("BB"), _A("BB"), "bb2(int,float)")); - REQUIRE_THAT( - src, HasCall(_A("BB"), _A("AA"), "aa2(int)")); + { + auto j = generate_sequence_json(diagram, *model); - save_puml(config.output_directory(), diagram->name + ".puml", src); - } + using namespace json; - { - auto j = generate_sequence_json(diagram, *model); + std::vector messages = { + FindMessage(j, "tmain()", "B", "b(int)"), + FindMessage(j, "B", "A", "a1(int)"), + FindMessage(j, "tmain()", "B", "b(std::string)"), + FindMessage(j, "tmain()", "BB", "bb1(int,int)"), + FindMessage(j, "BB", "AA", "aa1(int)"), + FindMessage( + j, "tmain()", "BB", + "bb1(int,std::string)")}; - using namespace json; + REQUIRE(std::is_sorted(messages.begin(), messages.end())); - std::vector messages = { - FindMessage(j, "tmain()", "B", "b(int)"), - FindMessage(j, "B", "A", "a1(int)"), - FindMessage(j, "tmain()", "B", "b(std::string)"), - FindMessage(j, "tmain()", "BB", "bb1(int,int)"), - FindMessage(j, "BB", "AA", "aa1(int)"), - FindMessage( - j, "tmain()", "BB", "bb1(int,std::string)")}; + save_json(config.output_directory(), diagram->name + ".json", j); + } - REQUIRE(std::is_sorted(messages.begin(), messages.end())); + { + auto src = generate_sequence_mermaid(diagram, *model); - save_json(config.output_directory(), diagram->name + ".json", j); - } + mermaid::SequenceDiagramAliasMatcher _A(src); + using mermaid::HasCall; - { - auto src = generate_sequence_mermaid(diagram, *model); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b(int)")); + REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a1(int)")); - mermaid::SequenceDiagramAliasMatcher _A(src); - using mermaid::HasCall; + REQUIRE_THAT(src, + HasCall(_A("tmain()"), _A("B"), "b(std::string)")); + REQUIRE_THAT(src, + HasCall( + _A("B"), _A("A"), + "a2(std::string)")); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b(int)")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a1(int)")); + REQUIRE_THAT( + src, HasCall(_A("tmain()"), _A("BB"), "bb1(int,int)")); + REQUIRE_THAT( + src, HasCall(_A("BB"), _A("AA"), "aa1(int)")); - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("B"), "b(std::string)")); - REQUIRE_THAT(src, - HasCall( - _A("B"), _A("A"), "a2(std::string)")); + REQUIRE_THAT( + src, HasCall(_A("tmain()"), _A("BB"), "bb2(int,int)")); + REQUIRE_THAT( + src, HasCall(_A("BB"), _A("AA"), "aa2(int)")); - REQUIRE_THAT( - src, HasCall(_A("tmain()"), _A("BB"), "bb1(int,int)")); - REQUIRE_THAT( - src, HasCall(_A("BB"), _A("AA"), "aa1(int)")); + REQUIRE_THAT(src, + HasCall(_A("tmain()"), _A("BB"), + "bb1(int,std::string)")); + REQUIRE_THAT( + src, HasCall(_A("BB"), _A("AA"), + "aa2(int)")); - REQUIRE_THAT( - src, HasCall(_A("tmain()"), _A("BB"), "bb2(int,int)")); - REQUIRE_THAT( - src, HasCall(_A("BB"), _A("AA"), "aa2(int)")); + REQUIRE_THAT(src, + HasCall(_A("tmain()"), _A("BB"), + "bb2(int,std::string)")); + REQUIRE_THAT( + src, HasCall(_A("BB"), _A("AA"), + "aa1(int)")); - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("BB"), - "bb1(int,std::string)")); - REQUIRE_THAT( - src, HasCall(_A("BB"), _A("AA"), "aa2(int)")); + REQUIRE_THAT( + src, HasCall(_A("tmain()"), _A("BB"), + "bb1(int,float)")); REQUIRE_THAT(src, HasCall( _A("BB"), + _A("BB"), "bb2(int,float)")); REQUIRE_THAT( src, + HasCall(_A("BB"), _A("AA"), "aa2(int)")); - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("BB"), - "bb2(int,std::string)")); - REQUIRE_THAT( - src, HasCall(_A("BB"), _A("AA"), "aa1(int)")); - - REQUIRE_THAT( - src, HasCall(_A("tmain()"), _A("BB"), "bb1(int,float)")); - REQUIRE_THAT(src, - HasCall( - _A("BB"), _A("BB"), "bb2(int,float)")); - REQUIRE_THAT( - src, HasCall(_A("BB"), _A("AA"), "aa2(int)")); - - save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + save_mermaid(config.output_directory(), diagram->name + ".mmd", + src); + }*/ } \ No newline at end of file diff --git a/tests/t20007/test_case.h b/tests/t20007/test_case.h index 97cfa231..0bfa1b19 100644 --- a/tests/t20007/test_case.h +++ b/tests/t20007/test_case.h @@ -16,73 +16,79 @@ * limitations under the License. */ -TEST_CASE("t20007", "[test-case][sequence]") +TEST_CASE("t20007") { - auto [config, db] = load_config("t20007"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20007_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20007", "t20007_sequence"); - REQUIRE(diagram->name == "t20007_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + {"tmain()", "Adder", "add(int &&,int &&)"}, // + {"tmain()", "Adder", + "add(int &&,float &&,double &&)"}, // + {"tmain()", "Adder", + "add(std::string &&,std::string &&,std::string &&)"} // + })); + }); + /* + { + auto src = generate_sequence_puml(diagram, *model); + AliasMatcher _A(src); - auto model = generate_sequence_diagram(*db, diagram); + REQUIRE_THAT(src, StartsWith("@startuml")); + REQUIRE_THAT(src, EndsWith("@enduml\n")); - REQUIRE(model->name() == "t20007_sequence"); + // Check if all calls exist + REQUIRE_THAT(src, + HasCall(_A("tmain()"), _A("Adder"), "add(int &&,int + &&)")); REQUIRE_THAT(src, HasCall(_A("tmain()"), + _A("Adder"), "add(int &&,float &&,double &&)")); + REQUIRE_THAT(src, + HasCall(_A("tmain()"), + _A("Adder"), + "add(std::string &&,std::string &&,std::string &&)")); - { - auto src = generate_sequence_puml(diagram, *model); - AliasMatcher _A(src); + save_puml(config.output_directory(), diagram->name + ".puml", + src); + } - REQUIRE_THAT(src, StartsWith("@startuml")); - REQUIRE_THAT(src, EndsWith("@enduml\n")); + { + auto j = generate_sequence_json(diagram, *model); - // Check if all calls exist - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("Adder"), "add(int &&,int &&)")); - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("Adder"), - "add(int &&,float &&,double &&)")); - REQUIRE_THAT(src, - HasCall(_A("tmain()"), - _A("Adder"), - "add(std::string &&,std::string &&,std::string &&)")); + using namespace json; - save_puml(config.output_directory(), diagram->name + ".puml", src); - } + std::vector messages = { + FindMessage(j, "tmain()", "Adder", "add(int &&,int + &&)"), FindMessage(j, "tmain()", "Adder", "add(int + &&,float &&,double &&)"), FindMessage(j, "tmain()", + "Adder", + "add(std::string &&,std::string &&,std::string &&)")}; - { - auto j = generate_sequence_json(diagram, *model); + REQUIRE(std::is_sorted(messages.begin(), messages.end())); - using namespace json; + save_json(config.output_directory(), diagram->name + ".json", + j); + } - std::vector messages = { - FindMessage(j, "tmain()", "Adder", "add(int &&,int &&)"), - FindMessage(j, "tmain()", "Adder", - "add(int &&,float &&,double &&)"), - FindMessage(j, "tmain()", - "Adder", - "add(std::string &&,std::string &&,std::string &&)")}; + { + auto src = generate_sequence_mermaid(diagram, *model); - REQUIRE(std::is_sorted(messages.begin(), messages.end())); + mermaid::SequenceDiagramAliasMatcher _A(src); + using mermaid::HasCall; - save_json(config.output_directory(), diagram->name + ".json", j); - } + REQUIRE_THAT(src, + HasCall(_A("tmain()"), _A("Adder"), "add(int &&,int + &&)")); REQUIRE_THAT(src, HasCall(_A("tmain()"), + _A("Adder"), "add(int &&,float &&,double &&)")); + REQUIRE_THAT(src, + HasCall(_A("tmain()"), + _A("Adder"), + "add(std::string &&,std::string &&,std::string &&)")); - { - auto src = generate_sequence_mermaid(diagram, *model); - - mermaid::SequenceDiagramAliasMatcher _A(src); - using mermaid::HasCall; - - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("Adder"), "add(int &&,int &&)")); - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("Adder"), - "add(int &&,float &&,double &&)")); - REQUIRE_THAT(src, - HasCall(_A("tmain()"), - _A("Adder"), - "add(std::string &&,std::string &&,std::string &&)")); - - save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + save_mermaid(config.output_directory(), diagram->name + ".mmd", + src); + }*/ } \ No newline at end of file diff --git a/tests/t20008/test_case.h b/tests/t20008/test_case.h index 0a98e6fd..ac9c7a05 100644 --- a/tests/t20008/test_case.h +++ b/tests/t20008/test_case.h @@ -16,91 +16,104 @@ * limitations under the License. */ -TEST_CASE("t20008", "[test-case][sequence]") +TEST_CASE("t20008") { - auto [config, db] = load_config("t20008"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20008_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20008", "t20008_sequence"); - REQUIRE(diagram->name == "t20008_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain()", "B", "b(int)"}, // + {"B", "A", "a1(int)"}, // - auto model = generate_sequence_diagram(*db, diagram); + {"tmain()", "B", "b(const char *)"}, // + {"B", "A", "a2(const char *)"}, // - REQUIRE(model->name() == "t20008_sequence"); + {"tmain()", "B", "b(std::string)"}, // + {"B", "A", "a3(std::string)"} // + })); - { - auto src = generate_sequence_puml(diagram, *model); - AliasMatcher _A(src); + REQUIRE(!HasMessage(src, {"B", "A", "a2(int)"})); + REQUIRE(!HasMessage(src, {"B", "A", "a3(int)"})); + }); + /* + { + auto src = generate_sequence_puml(diagram, *model); + AliasMatcher _A(src); - REQUIRE_THAT(src, StartsWith("@startuml")); - REQUIRE_THAT(src, EndsWith("@enduml\n")); + REQUIRE_THAT(src, StartsWith("@startuml")); + REQUIRE_THAT(src, EndsWith("@enduml\n")); - // Check if all calls exist - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b(int)")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a1(int)")); - // REQUIRE_THAT(puml, !HasCall(_A("B"), _A("A"), - // "a2(int)")); REQUIRE_THAT(puml, !HasCall(_A("B"), - // _A("A"), "a3(int)")); + // Check if all calls exist + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), + "b(int)")); REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), + "a1(int)")); + // REQUIRE_THAT(puml, !HasCall(_A("B"), _A("A"), + // "a2(int)")); REQUIRE_THAT(puml, !HasCall(_A("B"), + // _A("A"), "a3(int)")); - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("B"), "b(const char *)")); - REQUIRE_THAT(src, - HasCall(_A("B"), _A("A"), - "a2(const char *)")); + REQUIRE_THAT(src, + HasCall(_A("tmain()"), _A("B"), "b(const char + *)")); REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2(const char *)")); - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("B"), "b(std::string)")); - REQUIRE_THAT(src, - HasCall( - _A("B"), _A("A"), "a3(std::string)")); + REQUIRE_THAT(src, + HasCall(_A("tmain()"), _A("B"), + "b(std::string)")); REQUIRE_THAT(src, HasCall( _A("B"), + _A("A"), "a3(std::string)")); - save_puml(config.output_directory(), diagram->name + ".puml", src); - } + save_puml(config.output_directory(), diagram->name + ".puml", + src); + } - { - auto j = generate_sequence_json(diagram, *model); + { + auto j = generate_sequence_json(diagram, *model); - using namespace json; + using namespace json; - std::vector messages = { - FindMessage(j, "tmain()", "B", "b(int)"), - FindMessage(j, "B", "A", "a1(int)"), - FindMessage(j, "tmain()", "B", "b(const char *)"), - FindMessage( - j, "B", "A", "a2(const char *)"), - FindMessage(j, "tmain()", "B", "b(std::string)"), - FindMessage( - j, "B", "A", "a3(std::string)")}; + std::vector messages = { + FindMessage(j, "tmain()", "B", "b(int)"), + FindMessage(j, "B", "A", "a1(int)"), + FindMessage(j, "tmain()", "B", "b(const char + *)"), FindMessage( j, "B", "A", "a2(const + char *)"), FindMessage(j, "tmain()", "B", + "b(std::string)"), FindMessage( j, "B", + "A", "a3(std::string)")}; - REQUIRE(std::is_sorted(messages.begin(), messages.end())); + REQUIRE(std::is_sorted(messages.begin(), messages.end())); - save_json(config.output_directory(), diagram->name + ".json", j); - } + save_json(config.output_directory(), diagram->name + ".json", + j); + } - { - auto src = generate_sequence_mermaid(diagram, *model); + { + auto src = generate_sequence_mermaid(diagram, *model); - mermaid::SequenceDiagramAliasMatcher _A(src); - using mermaid::HasCall; + mermaid::SequenceDiagramAliasMatcher _A(src); + using mermaid::HasCall; - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b(int)")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a1(int)")); - // REQUIRE_THAT(puml, !HasCall(_A("B"), _A("A"), - // "a2(int)")); REQUIRE_THAT(puml, !HasCall(_A("B"), - // _A("A"), "a3(int)")); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), + "b(int)")); REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), + "a1(int)")); + // REQUIRE_THAT(puml, !HasCall(_A("B"), _A("A"), + // "a2(int)")); REQUIRE_THAT(puml, !HasCall(_A("B"), + // _A("A"), "a3(int)")); - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("B"), "b(const char *)")); - REQUIRE_THAT(src, - HasCall(_A("B"), _A("A"), - "a2(const char *)")); + REQUIRE_THAT(src, + HasCall(_A("tmain()"), _A("B"), "b(const char + *)")); REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2(const char *)")); - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("B"), "b(std::string)")); - REQUIRE_THAT(src, - HasCall( - _A("B"), _A("A"), "a3(std::string)")); + REQUIRE_THAT(src, + HasCall(_A("tmain()"), _A("B"), + "b(std::string)")); REQUIRE_THAT(src, HasCall( _A("B"), + _A("A"), "a3(std::string)")); - save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + save_mermaid(config.output_directory(), diagram->name + ".mmd", + src); + }*/ } \ No newline at end of file diff --git a/tests/t20009/test_case.h b/tests/t20009/test_case.h index 64bc4235..0a7600bb 100644 --- a/tests/t20009/test_case.h +++ b/tests/t20009/test_case.h @@ -16,78 +16,93 @@ * limitations under the License. */ -TEST_CASE("t20009", "[test-case][sequence]") +TEST_CASE("t20009") { - auto [config, db] = load_config("t20009"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20009_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20009", "t20009_sequence"); - REQUIRE(diagram->name == "t20009_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain()", "B", "b(std::string)"}, // + {"B", "A", "a(std::string)"}, // - auto model = generate_sequence_diagram(*db, diagram); + {"tmain()", "B", "b(int)"}, // + {"B", "A", "a(int)"}, // - REQUIRE(model->name() == "t20009_sequence"); + {"tmain()", "B", "b(float)"}, // + {"B", "A", "a(float)"} // + })); + }); + /* + { + auto src = generate_sequence_puml(diagram, *model); + AliasMatcher _A(src); - { - auto src = generate_sequence_puml(diagram, *model); - AliasMatcher _A(src); + REQUIRE_THAT(src, StartsWith("@startuml")); + REQUIRE_THAT(src, EndsWith("@enduml\n")); - REQUIRE_THAT(src, StartsWith("@startuml")); - REQUIRE_THAT(src, EndsWith("@enduml\n")); + // Check if all calls exist + REQUIRE_THAT(src, + HasCall(_A("tmain()"), _A("B"), "b(std::string)")); + REQUIRE_THAT(src, + HasCall( + _A("B"), _A("A"), + "a(std::string)")); - // Check if all calls exist - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("B"), "b(std::string)")); - REQUIRE_THAT(src, - HasCall( - _A("B"), _A("A"), "a(std::string)")); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b(int)")); + REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a(int)")); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b(int)")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a(int)")); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), + "b(float)")); REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), + "a(float)")); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b(float)")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a(float)")); + save_puml(config.output_directory(), diagram->name + ".puml", src); + } - save_puml(config.output_directory(), diagram->name + ".puml", src); - } + { + auto j = generate_sequence_json(diagram, *model); - { - auto j = generate_sequence_json(diagram, *model); + using namespace json; - using namespace json; + std::vector messages = { + FindMessage(j, "tmain()", "B", "b(std::string)"), + FindMessage( + j, "B", "A", "a(std::string)"), + FindMessage(j, "tmain()", "B", "b(int)"), + FindMessage(j, "B", "A", "a(int)"), + FindMessage(j, "tmain()", "B", "b(float)"), + FindMessage(j, "B", "A", "a(float)")}; - std::vector messages = { - FindMessage(j, "tmain()", "B", "b(std::string)"), - FindMessage( - j, "B", "A", "a(std::string)"), - FindMessage(j, "tmain()", "B", "b(int)"), - FindMessage(j, "B", "A", "a(int)"), - FindMessage(j, "tmain()", "B", "b(float)"), - FindMessage(j, "B", "A", "a(float)")}; + REQUIRE(std::is_sorted(messages.begin(), messages.end())); - REQUIRE(std::is_sorted(messages.begin(), messages.end())); + save_json(config.output_directory(), diagram->name + ".json", j); + } - save_json(config.output_directory(), diagram->name + ".json", j); - } + { + auto src = generate_sequence_mermaid(diagram, *model); - { - auto src = generate_sequence_mermaid(diagram, *model); + mermaid::SequenceDiagramAliasMatcher _A(src); + using mermaid::HasCall; - mermaid::SequenceDiagramAliasMatcher _A(src); - using mermaid::HasCall; + REQUIRE_THAT(src, + HasCall(_A("tmain()"), _A("B"), "b(std::string)")); + REQUIRE_THAT(src, + HasCall( + _A("B"), _A("A"), + "a(std::string)")); - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("B"), "b(std::string)")); - REQUIRE_THAT(src, - HasCall( - _A("B"), _A("A"), "a(std::string)")); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b(int)")); + REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a(int)")); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b(int)")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a(int)")); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), + "b(float)")); REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), + "a(float)")); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b(float)")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a(float)")); - - save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + save_mermaid(config.output_directory(), diagram->name + ".mmd", + src); + }*/ } \ No newline at end of file diff --git a/tests/t20010/test_case.h b/tests/t20010/test_case.h index a4e0f76c..e17b4f57 100644 --- a/tests/t20010/test_case.h +++ b/tests/t20010/test_case.h @@ -16,79 +16,92 @@ * limitations under the License. */ -TEST_CASE("t20010", "[test-case][sequence]") +TEST_CASE("t20010") { - auto [config, db] = load_config("t20010"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20010_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20010", "t20010_sequence"); - REQUIRE(diagram->name == "t20010_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + {"tmain()", "B", "b1()"}, // + {"B", "A", "a1()"}, // - auto model = generate_sequence_diagram(*db, diagram); + {"tmain()", "B", "b2()"}, // + {"B", "A", "a2()"}, // - REQUIRE(model->name() == "t20010_sequence"); + {"tmain()", "B", "b3()"}, // + {"B", "A", "a3()"}, // - { - auto src = generate_sequence_puml(diagram, *model); - AliasMatcher _A(src); + {"tmain()", "B", "b4()"}, // + {"B", "A", "a4()"} // + })); + }); + /* + { + auto src = generate_sequence_puml(diagram, *model); + AliasMatcher _A(src); - REQUIRE_THAT(src, StartsWith("@startuml")); - REQUIRE_THAT(src, EndsWith("@enduml\n")); + REQUIRE_THAT(src, StartsWith("@startuml")); + REQUIRE_THAT(src, EndsWith("@enduml\n")); - // Check if all calls exist - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b1()")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a1()")); + // Check if all calls exist + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b1()")); + REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a1()")); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b2()")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()")); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b2()")); + REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()")); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b3()")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a3()")); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b3()")); + REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a3()")); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b4()")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a4()")); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b4()")); + REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a4()")); - save_puml(config.output_directory(), diagram->name + ".puml", src); - } + save_puml(config.output_directory(), diagram->name + ".puml", src); + } - { - auto j = generate_sequence_json(diagram, *model); + { + auto j = generate_sequence_json(diagram, *model); - using namespace json; + using namespace json; - std::vector messages = { - FindMessage(j, "tmain()", "B", "b1()"), - FindMessage(j, "B", "A", "a1()"), - FindMessage(j, "tmain()", "B", "b2()"), - FindMessage(j, "B", "A", "a2()"), - FindMessage(j, "tmain()", "B", "b3()"), - FindMessage(j, "B", "A", "a3()"), - FindMessage(j, "tmain()", "B", "b4()"), - FindMessage(j, "B", "A", "a4()")}; + std::vector messages = { + FindMessage(j, "tmain()", "B", "b1()"), + FindMessage(j, "B", "A", "a1()"), + FindMessage(j, "tmain()", "B", "b2()"), + FindMessage(j, "B", "A", "a2()"), + FindMessage(j, "tmain()", "B", "b3()"), + FindMessage(j, "B", "A", "a3()"), + FindMessage(j, "tmain()", "B", "b4()"), + FindMessage(j, "B", "A", "a4()")}; - REQUIRE(std::is_sorted(messages.begin(), messages.end())); + REQUIRE(std::is_sorted(messages.begin(), messages.end())); - save_json(config.output_directory(), diagram->name + ".json", j); - } + save_json(config.output_directory(), diagram->name + ".json", j); + } - { - auto src = generate_sequence_mermaid(diagram, *model); + { + auto src = generate_sequence_mermaid(diagram, *model); - mermaid::SequenceDiagramAliasMatcher _A(src); - using mermaid::HasCall; + mermaid::SequenceDiagramAliasMatcher _A(src); + using mermaid::HasCall; - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b1()")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a1()")); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b1()")); + REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a1()")); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b2()")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()")); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b2()")); + REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()")); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b3()")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a3()")); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b3()")); + REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a3()")); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b4()")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a4()")); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b4()")); + REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a4()")); - save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + save_mermaid(config.output_directory(), diagram->name + ".mmd", + src); + }*/ } \ No newline at end of file diff --git a/tests/t20011/test_case.h b/tests/t20011/test_case.h index e6f4b81a..9923d2e7 100644 --- a/tests/t20011/test_case.h +++ b/tests/t20011/test_case.h @@ -16,17 +16,28 @@ * limitations under the License. */ -TEST_CASE("t20011", "[test-case][sequence]") +TEST_CASE("t20011") { - auto [config, db] = load_config("t20011"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20011_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20011", "t20011_sequence"); - REQUIRE(diagram->name == "t20011_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain()", "A", "a(int)"}, // + {"A", "A", "a(int)"}, // - auto model = generate_sequence_diagram(*db, diagram); + {"tmain()", "A", "b(int)"}, // + {"A", "A", "c(int)"}, // + {"A", "A", "d(int)"}, // + {"A", "A", "b(int)"} // + })); + }); - REQUIRE(model->name() == "t20011_sequence"); + /* { auto src = generate_sequence_puml(diagram, *model); AliasMatcher _A(src); @@ -80,4 +91,5 @@ TEST_CASE("t20011", "[test-case][sequence]") save_mermaid(config.output_directory(), diagram->name + ".mmd", src); } + */ } \ No newline at end of file diff --git a/tests/t20012/test_case.h b/tests/t20012/test_case.h index 918a7d96..dd7a50f8 100644 --- a/tests/t20012/test_case.h +++ b/tests/t20012/test_case.h @@ -16,17 +16,60 @@ * limitations under the License. */ -TEST_CASE("t20012", "[test-case][sequence]") +TEST_CASE("t20012") { - auto [config, db] = load_config("t20012"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20012_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20012", "t20012_sequence"); - REQUIRE(diagram->name == "t20012_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + {"tmain()", "tmain()::(lambda t20012.cc:67:20)", + "operator()() const"}, // + {"tmain()::(lambda t20012.cc:67:20)", "A", "a()"}, // + {"A", "A", "aa()"}, // + {"A", "A", "aaa()"}, // - auto model = generate_sequence_diagram(*db, diagram); + {"tmain()::(lambda t20012.cc:67:20)", "B", "b()"}, // + {"B", "B", "bb()"}, // + {"B", "B", "bbb()"}, // - REQUIRE(model->name() == "t20012_sequence"); + {"tmain()", "tmain()::(lambda t20012.cc:80:20)", + "operator()() const"}, // + {"tmain()::(lambda t20012.cc:80:20)", "C", "c()"}, // + {"C", "C", "cc()"}, // + {"C", "C", "ccc()"}, // + + {"tmain()::(lambda t20012.cc:80:20)", + "tmain()::(lambda t20012.cc:67:20)", + "operator()() const"}, // + + {"tmain()::(lambda t20012.cc:67:20)", "A", "a()"}, // + + {"A", "A", "aa()"}, // + {"A", "A", "aaa()"}, // + + {"tmain()::(lambda t20012.cc:67:20)", "B", "b()"}, // + {"B", "B", "bb()"}, // + {"B", "B", "bbb()"}, // + + {"tmain()", "R<(lambda at t20012.cc:86:9)>", + "R((lambda at t20012.cc:86:9) &&)"}, // + {"tmain()", "R<(lambda at t20012.cc:86:9)>", "r()"}, // + {"R<(lambda at t20012.cc:86:9)>", + "tmain()::(lambda t20012.cc:86:9)", + "operator()() const"}, // + {"tmain()::(lambda t20012.cc:86:9)", "C", "c()"}, // + + {"tmain()", "tmain()::(lambda t20012.cc:94:9)", + "operator()(auto) const"}, // + {"tmain()::(lambda t20012.cc:94:9)", "D", "add5(int) const"} // + })); + }); + + /* { auto src = generate_sequence_puml(diagram, *model); AliasMatcher _A(src); @@ -155,4 +198,5 @@ TEST_CASE("t20012", "[test-case][sequence]") save_mermaid(config.output_directory(), diagram->name + ".mmd", src); } + */ } diff --git a/tests/t20013/test_case.h b/tests/t20013/test_case.h index 733f7e20..e0594057 100644 --- a/tests/t20013/test_case.h +++ b/tests/t20013/test_case.h @@ -16,17 +16,28 @@ * limitations under the License. */ -TEST_CASE("t20013", "[test-case][sequence]") +TEST_CASE("t20013") { - auto [config, db] = load_config("t20013"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20013_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20013", "t20013_sequence"); - REQUIRE(diagram->name == "t20013_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain(int,char **)", "B", "b(int)"}, // + {"B", "A", "a1(int)"}, // - auto model = generate_sequence_diagram(*db, diagram); + {"tmain(int,char **)", "B", "b(double)"}, // + {"B", "A", "a2(double)"}, // - REQUIRE(model->name() == "t20013_sequence"); + {"tmain(int,char **)", "B", "b(const char *)"}, // + {"B", "A", "a3(const char *)"} // + })); + }); + /* { auto src = generate_sequence_puml(diagram, *model); AliasMatcher _A(src); @@ -85,5 +96,5 @@ TEST_CASE("t20013", "[test-case][sequence]") REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a3(const char *)")); save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + }*/ } \ No newline at end of file diff --git a/tests/t20014/test_case.h b/tests/t20014/test_case.h index 8bb84bbc..d835bb9f 100644 --- a/tests/t20014/test_case.h +++ b/tests/t20014/test_case.h @@ -16,17 +16,28 @@ * limitations under the License. */ -TEST_CASE("t20014", "[test-case][sequence]") +TEST_CASE("t20014") { - auto [config, db] = load_config("t20014"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20014_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20014", "t20014_sequence"); - REQUIRE(diagram->name == "t20014_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain()", "B", "b1(int,int)"}, // + {"B", "A", "a1(int,int)"}, // - auto model = generate_sequence_diagram(*db, diagram); + {"tmain()", "B", "b2(int,int)"}, // + {"B", "A", "a2(int,int)"}, // - REQUIRE(model->name() == "t20014_sequence"); + {"tmain()", "C", "c1(int,int)"}, // + {"C", "B", "b1(int,int)"}, // + })); + }); +/* { auto src = generate_sequence_puml(diagram, *model); AliasMatcher _A(src); @@ -84,4 +95,5 @@ TEST_CASE("t20014", "[test-case][sequence]") save_mermaid(config.output_directory(), diagram->name + ".mmd", src); } -} \ No newline at end of file +*/ + } \ No newline at end of file diff --git a/tests/t20015/test_case.h b/tests/t20015/test_case.h index 259cafb7..2a752921 100644 --- a/tests/t20015/test_case.h +++ b/tests/t20015/test_case.h @@ -16,69 +16,82 @@ * limitations under the License. */ -TEST_CASE("t20015", "[test-case][sequence]") +TEST_CASE("t20015") { - auto [config, db] = load_config("t20015"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20015_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20015", "t20015_sequence"); - REQUIRE(diagram->name == "t20015_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + {"tmain()", "B", "setup_a(std::shared_ptr &)"} // + })); - auto model = generate_sequence_diagram(*db, diagram); + REQUIRE(!HasMessage(src, {"B", {"detail", "A"}, "set_x(int)"})); + REQUIRE(!HasMessage(src, {"B", {"detail" ,"A"}, "set_y(int)"})); + REQUIRE(!HasMessage(src, {"B", {"detail", "A"}, "set_z(int)"})); - REQUIRE(model->name() == "t20015_sequence"); - { - auto src = generate_sequence_puml(diagram, *model); - AliasMatcher _A(src); + REQUIRE(!HasMessage(src, {"B", "B", "set_x(int)"})); + REQUIRE(!HasMessage(src, {"B", "B", "set_y(int)"})); + REQUIRE(!HasMessage(src, {"B", "B", "set_z(int)"})); + }); + /* + { + auto src = generate_sequence_puml(diagram, *model); + AliasMatcher _A(src); - REQUIRE_THAT(src, StartsWith("@startuml")); - REQUIRE_THAT(src, EndsWith("@enduml\n")); + REQUIRE_THAT(src, StartsWith("@startuml")); + REQUIRE_THAT(src, EndsWith("@enduml\n")); - // Check if all calls exist - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("B"), - "setup_a(std::shared_ptr &)")); - REQUIRE_THAT(src, !HasCall(_A("B"), _A("detail::A"), "set_x(int)")); - REQUIRE_THAT(src, !HasCall(_A("B"), _A("detail::A"), "set_y(int)")); - REQUIRE_THAT(src, !HasCall(_A("B"), _A("detail::A"), "set_z(int)")); + // Check if all calls exist + REQUIRE_THAT(src, + HasCall(_A("tmain()"), _A("B"), + "setup_a(std::shared_ptr &)")); + REQUIRE_THAT(src, !HasCall(_A("B"), _A("detail::A"), "set_x(int)")); + REQUIRE_THAT(src, !HasCall(_A("B"), _A("detail::A"), "set_y(int)")); + REQUIRE_THAT(src, !HasCall(_A("B"), _A("detail::A"), "set_z(int)")); - REQUIRE_THAT(src, !HasCall(_A("B"), _A("B"), "set_x(int)")); - REQUIRE_THAT(src, !HasCall(_A("B"), _A("B"), "set_y(int)")); - REQUIRE_THAT(src, !HasCall(_A("B"), _A("B"), "set_z(int)")); + REQUIRE_THAT(src, !HasCall(_A("B"), _A("B"), "set_x(int)")); + REQUIRE_THAT(src, !HasCall(_A("B"), _A("B"), "set_y(int)")); + REQUIRE_THAT(src, !HasCall(_A("B"), _A("B"), "set_z(int)")); - save_puml(config.output_directory(), diagram->name + ".puml", src); - } + save_puml(config.output_directory(), diagram->name + ".puml", src); + } - { - auto j = generate_sequence_json(diagram, *model); + { + auto j = generate_sequence_json(diagram, *model); - using namespace json; + using namespace json; - std::vector messages = {FindMessage( - j, "tmain()", "B", "setup_a(std::shared_ptr &)")}; + std::vector messages = {FindMessage( + j, "tmain()", "B", "setup_a(std::shared_ptr &)")}; - REQUIRE(std::is_sorted(messages.begin(), messages.end())); + REQUIRE(std::is_sorted(messages.begin(), messages.end())); - save_json(config.output_directory(), diagram->name + ".json", j); - } + save_json(config.output_directory(), diagram->name + ".json", j); + } - { - auto src = generate_sequence_mermaid(diagram, *model); + { + auto src = generate_sequence_mermaid(diagram, *model); - mermaid::SequenceDiagramAliasMatcher _A(src); - using mermaid::HasCall; + mermaid::SequenceDiagramAliasMatcher _A(src); + using mermaid::HasCall; - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("B"), - "setup_a(std::shared_ptr &)")); - REQUIRE_THAT(src, !HasCall(_A("B"), _A("detail::A"), "set_x(int)")); - REQUIRE_THAT(src, !HasCall(_A("B"), _A("detail::A"), "set_y(int)")); - REQUIRE_THAT(src, !HasCall(_A("B"), _A("detail::A"), "set_z(int)")); + REQUIRE_THAT(src, + HasCall(_A("tmain()"), _A("B"), + "setup_a(std::shared_ptr &)")); + REQUIRE_THAT(src, !HasCall(_A("B"), _A("detail::A"), "set_x(int)")); + REQUIRE_THAT(src, !HasCall(_A("B"), _A("detail::A"), "set_y(int)")); + REQUIRE_THAT(src, !HasCall(_A("B"), _A("detail::A"), "set_z(int)")); - REQUIRE_THAT(src, !HasCall(_A("B"), _A("B"), "set_x(int)")); - REQUIRE_THAT(src, !HasCall(_A("B"), _A("B"), "set_y(int)")); - REQUIRE_THAT(src, !HasCall(_A("B"), _A("B"), "set_z(int)")); + REQUIRE_THAT(src, !HasCall(_A("B"), _A("B"), "set_x(int)")); + REQUIRE_THAT(src, !HasCall(_A("B"), _A("B"), "set_y(int)")); + REQUIRE_THAT(src, !HasCall(_A("B"), _A("B"), "set_z(int)")); - save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + save_mermaid(config.output_directory(), diagram->name + ".mmd", + src); + } + */ } \ No newline at end of file diff --git a/tests/t20016/test_case.h b/tests/t20016/test_case.h index b9bf1d12..ec213523 100644 --- a/tests/t20016/test_case.h +++ b/tests/t20016/test_case.h @@ -16,62 +16,77 @@ * limitations under the License. */ -TEST_CASE("t20016", "[test-case][sequence]") +TEST_CASE("t20016") { - auto [config, db] = load_config("t20016"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20016_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20016", "t20016_sequence"); - REQUIRE(diagram->name == "t20016_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain()", "B", "b1(long)"}, // + {"B", "A", "a1(int)"}, // + {"tmain()", "B", "b2(long)"}, // + {"B", "A", "a2(const long &)"} // + })); + }); + /* + { + auto src = generate_sequence_puml(diagram, *model); + AliasMatcher _A(src); - auto model = generate_sequence_diagram(*db, diagram); + REQUIRE_THAT(src, StartsWith("@startuml")); + REQUIRE_THAT(src, EndsWith("@enduml\n")); - REQUIRE(model->name() == "t20016_sequence"); - { - auto src = generate_sequence_puml(diagram, *model); - AliasMatcher _A(src); + // Check if all calls exist + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), + "b1(long)")); REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), + "a1(int)")); - REQUIRE_THAT(src, StartsWith("@startuml")); - REQUIRE_THAT(src, EndsWith("@enduml\n")); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), + "b2(long)")); REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), + "a2(const long &)")); - // Check if all calls exist - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b1(long)")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a1(int)")); + save_puml(config.output_directory(), diagram->name + ".puml", + src); + } - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b2(long)")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2(const long &)")); + { + auto j = generate_sequence_json(diagram, *model); - save_puml(config.output_directory(), diagram->name + ".puml", src); - } + using namespace json; - { - auto j = generate_sequence_json(diagram, *model); + std::vector messages = { + FindMessage(j, "tmain()", "B", "b1(long)"), + FindMessage(j, "B", "A", "a1(int)"), + FindMessage(j, "tmain()", "B", "b2(long)"), + FindMessage(j, "B", "A", "a2(const long &)")}; - using namespace json; + REQUIRE(std::is_sorted(messages.begin(), messages.end())); - std::vector messages = { - FindMessage(j, "tmain()", "B", "b1(long)"), - FindMessage(j, "B", "A", "a1(int)"), - FindMessage(j, "tmain()", "B", "b2(long)"), - FindMessage(j, "B", "A", "a2(const long &)")}; + save_json(config.output_directory(), diagram->name + ".json", + j); + } - REQUIRE(std::is_sorted(messages.begin(), messages.end())); + { + auto src = generate_sequence_mermaid(diagram, *model); - save_json(config.output_directory(), diagram->name + ".json", j); - } + mermaid::SequenceDiagramAliasMatcher _A(src); + using mermaid::HasCall; - { - auto src = generate_sequence_mermaid(diagram, *model); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), + "b1(long)")); REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), + "a1(int)")); - mermaid::SequenceDiagramAliasMatcher _A(src); - using mermaid::HasCall; + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), + "b2(long)")); REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), + "a2(const long &)")); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b1(long)")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a1(int)")); - - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b2(long)")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2(const long &)")); - - save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + save_mermaid(config.output_directory(), diagram->name + ".mmd", + src); + } + */ } \ No newline at end of file diff --git a/tests/t20017/test_case.h b/tests/t20017/test_case.h index 37519ce6..9ae03f82 100644 --- a/tests/t20017/test_case.h +++ b/tests/t20017/test_case.h @@ -16,17 +16,27 @@ * limitations under the License. */ -TEST_CASE("t20017", "[test-case][sequence]") +TEST_CASE("t20017") { - auto [config, db] = load_config("t20017"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20017_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20017", "t20017_sequence"); - REQUIRE(diagram->name == "t20017_sequence"); - - auto model = generate_sequence_diagram(*db, diagram); - - REQUIRE(model->name() == "t20017_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + // {Entrypoint{}, "t20017.cc", "tmain()"}, // + {"t20017.cc", "include/t20017_a.h", "a3(int,int)"}, // + {"t20017.cc", "include/t20017_b.h", "b1(int,int)"}, // + /* {"t20017.cc", "include/t20017_a.h", "a2(int,int)"}, // + {"t20017.cc", "include/t20017_a.h", "a1(int,int)"}, // + {"t20017.cc", "include/t20017_b.h", "b2(int,int)"}, // + {Exitpoint{}, "t20017.cc"}, //*/ + })); + }); + /* { auto src = generate_sequence_puml(diagram, *model); AliasMatcher _A(src); @@ -105,5 +115,5 @@ TEST_CASE("t20017", "[test-case][sequence]") REQUIRE_THAT(src, HasExitpoint(_A("t20017.cc"))); save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + }*/ } \ No newline at end of file diff --git a/tests/t20018/test_case.h b/tests/t20018/test_case.h index ae618cae..c43591ef 100644 --- a/tests/t20018/test_case.h +++ b/tests/t20018/test_case.h @@ -16,88 +16,97 @@ * limitations under the License. */ -TEST_CASE("t20018", "[test-case][sequence]") +TEST_CASE("t20018") { - auto [config, db] = load_config("t20018"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20018_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20018", "t20018_sequence"); - REQUIRE(diagram->name == "t20018_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain()", "Answer,120>", "print()", Static{}}, // + {"Answer,120>", "Factorial<5>", "print(int)", + Static{}}, // + {"Factorial<5>", "Factorial<4>", "print(int)", Static{}}, // + {"Factorial<4>", "Factorial<3>", "print(int)", Static{}}, // + {"Factorial<3>", "Factorial<2>", "print(int)", Static{}}, // + {"Factorial<2>", "Factorial<1>", "print(int)", Static{}}, // + {"Factorial<1>", "Factorial<0>", "print(int)", Static{}}, // + })); + }); + /* + { + auto src = generate_sequence_puml(diagram, *model); + AliasMatcher _A(src); - auto model = generate_sequence_diagram(*db, diagram); + REQUIRE_THAT(src, StartsWith("@startuml")); + REQUIRE_THAT(src, EndsWith("@enduml\n")); - REQUIRE(model->name() == "t20018_sequence"); + // Check if all calls exist + REQUIRE_THAT(src, + HasCall( + _A("tmain()"), _A("Answer,120>"), + "__print()__")); REQUIRE_THAT(src, + HasCall(_A("Answer,120>"), _A("Factorial<5>"), + "__print(int)__")); + REQUIRE_THAT(src, + HasCall(_A("Factorial<5>"), _A("Factorial<4>"), + "__print(int)__")); REQUIRE_THAT(src, HasCall(_A("Factorial<4>"), + _A("Factorial<3>"), "__print(int)__")); REQUIRE_THAT(src, + HasCall(_A("Factorial<3>"), _A("Factorial<2>"), + "__print(int)__")); REQUIRE_THAT(src, HasCall(_A("Factorial<2>"), + _A("Factorial<1>"), "__print(int)__")); REQUIRE_THAT(src, + HasCall(_A("Factorial<1>"), _A("Factorial<0>"), + "__print(int)__")); - { - auto src = generate_sequence_puml(diagram, *model); - AliasMatcher _A(src); + save_puml(config.output_directory(), diagram->name + ".puml", src); + } - REQUIRE_THAT(src, StartsWith("@startuml")); - REQUIRE_THAT(src, EndsWith("@enduml\n")); + { + auto j = generate_sequence_json(diagram, *model); - // Check if all calls exist - REQUIRE_THAT(src, - HasCall( - _A("tmain()"), _A("Answer,120>"), "__print()__")); - REQUIRE_THAT(src, - HasCall(_A("Answer,120>"), _A("Factorial<5>"), - "__print(int)__")); - REQUIRE_THAT(src, - HasCall(_A("Factorial<5>"), _A("Factorial<4>"), "__print(int)__")); - REQUIRE_THAT(src, - HasCall(_A("Factorial<4>"), _A("Factorial<3>"), "__print(int)__")); - REQUIRE_THAT(src, - HasCall(_A("Factorial<3>"), _A("Factorial<2>"), "__print(int)__")); - REQUIRE_THAT(src, - HasCall(_A("Factorial<2>"), _A("Factorial<1>"), "__print(int)__")); - REQUIRE_THAT(src, - HasCall(_A("Factorial<1>"), _A("Factorial<0>"), "__print(int)__")); + using namespace json; - save_puml(config.output_directory(), diagram->name + ".puml", src); - } + std::vector messages = { + FindMessage(j, "tmain()", "Answer,120>", + "print()"), FindMessage( j, "Answer,120>", "Factorial<5>", + "print(int)"), FindMessage(j, "Factorial<5>", "Factorial<4>", + "print(int)"), FindMessage(j, "Factorial<4>", "Factorial<3>", + "print(int)"), FindMessage(j, "Factorial<3>", "Factorial<2>", + "print(int)"), FindMessage(j, "Factorial<2>", "Factorial<1>", + "print(int)"), FindMessage(j, "Factorial<1>", "Factorial<0>", + "print(int)")}; - { - auto j = generate_sequence_json(diagram, *model); + REQUIRE(std::is_sorted(messages.begin(), messages.end())); - using namespace json; + save_json(config.output_directory(), diagram->name + ".json", j); + } - std::vector messages = { - FindMessage(j, "tmain()", "Answer,120>", "print()"), - FindMessage( - j, "Answer,120>", "Factorial<5>", "print(int)"), - FindMessage(j, "Factorial<5>", "Factorial<4>", "print(int)"), - FindMessage(j, "Factorial<4>", "Factorial<3>", "print(int)"), - FindMessage(j, "Factorial<3>", "Factorial<2>", "print(int)"), - FindMessage(j, "Factorial<2>", "Factorial<1>", "print(int)"), - FindMessage(j, "Factorial<1>", "Factorial<0>", "print(int)")}; + { + auto src = generate_sequence_mermaid(diagram, *model); - REQUIRE(std::is_sorted(messages.begin(), messages.end())); + mermaid::SequenceDiagramAliasMatcher _A(src); + using mermaid::HasCall; - save_json(config.output_directory(), diagram->name + ".json", j); - } + REQUIRE_THAT(src, + HasCall(_A("tmain()"), _A("Answer,120>"), + "print()")); REQUIRE_THAT(src, HasCall(_A("Answer,120>"), + _A("Factorial<5>"), "print(int)")); REQUIRE_THAT( src, + HasCall(_A("Factorial<5>"), _A("Factorial<4>"), "print(int)")); + REQUIRE_THAT( + src, HasCall(_A("Factorial<4>"), _A("Factorial<3>"), + "print(int)")); REQUIRE_THAT( src, HasCall(_A("Factorial<3>"), + _A("Factorial<2>"), "print(int)")); REQUIRE_THAT( src, + HasCall(_A("Factorial<2>"), _A("Factorial<1>"), "print(int)")); + REQUIRE_THAT( + src, HasCall(_A("Factorial<1>"), _A("Factorial<0>"), + "print(int)")); - { - auto src = generate_sequence_mermaid(diagram, *model); - - mermaid::SequenceDiagramAliasMatcher _A(src); - using mermaid::HasCall; - - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("Answer,120>"), "print()")); - REQUIRE_THAT(src, - HasCall(_A("Answer,120>"), _A("Factorial<5>"), - "print(int)")); - REQUIRE_THAT( - src, HasCall(_A("Factorial<5>"), _A("Factorial<4>"), "print(int)")); - REQUIRE_THAT( - src, HasCall(_A("Factorial<4>"), _A("Factorial<3>"), "print(int)")); - REQUIRE_THAT( - src, HasCall(_A("Factorial<3>"), _A("Factorial<2>"), "print(int)")); - REQUIRE_THAT( - src, HasCall(_A("Factorial<2>"), _A("Factorial<1>"), "print(int)")); - REQUIRE_THAT( - src, HasCall(_A("Factorial<1>"), _A("Factorial<0>"), "print(int)")); - - save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + save_mermaid(config.output_directory(), diagram->name + ".mmd", + src); + } + */ } \ No newline at end of file diff --git a/tests/t20019/test_case.h b/tests/t20019/test_case.h index 195655ff..6f809823 100644 --- a/tests/t20019/test_case.h +++ b/tests/t20019/test_case.h @@ -16,18 +16,24 @@ * limitations under the License. */ -TEST_CASE("t20019", "[test-case][sequence]") +TEST_CASE("t20019") { - auto [config, db] = load_config("t20019"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20019_sequence"]; - - REQUIRE(diagram->name == "t20019_sequence"); - - auto model = generate_sequence_diagram(*db, diagram); - - REQUIRE(model->name() == "t20019_sequence"); + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20019", "t20019_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain()", "Base", "name()"}, // + {"Base", "D1", "impl()"}, // + {"tmain()", "Base", "name()"}, // + {"Base", "D2", "impl()"} // + })); + }); +/* { auto src = generate_sequence_puml(diagram, *model); AliasMatcher _A(src); @@ -73,4 +79,5 @@ TEST_CASE("t20019", "[test-case][sequence]") save_mermaid(config.output_directory(), diagram->name + ".mmd", src); } + */ } \ No newline at end of file diff --git a/tests/t20020/test_case.h b/tests/t20020/test_case.h index bc5c2d0d..1653e737 100644 --- a/tests/t20020/test_case.h +++ b/tests/t20020/test_case.h @@ -16,95 +16,115 @@ * limitations under the License. */ -TEST_CASE("t20020", "[test-case][sequence]") +TEST_CASE("t20020") { - auto [config, db] = load_config("t20020"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20020_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20020", "t20020_sequence"); - REQUIRE(diagram->name == "t20020_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain()", "A", "a1()"}, // + {"tmain()", "A", "a5()"}, // + {"tmain()", "A", "a2()", InControlCondition{}}, // + {"tmain()", "C", "c3(int)", InControlCondition{}}, // + {"tmain()", "B", "b1()"}, // + {"tmain()", "A", "a3()", InControlCondition{}}, // + {"tmain()", "B", "b2()"}, // + {"tmain()", "A", "a4()"}, // + {"tmain()", "B", "log()"}, // + {"tmain()", "C", "c1() const"}, // + {"C", "C", "c2() const", InControlCondition{}}, // + {"C", "C", "log() const"}, // + {"tmain()", "D", "d1(int,int)"}, // + })); + }); + /* + { + auto src = generate_sequence_puml(diagram, *model); + AliasMatcher _A(src); - auto model = generate_sequence_diagram(*db, diagram); + REQUIRE_THAT(src, StartsWith("@startuml")); + REQUIRE_THAT(src, EndsWith("@enduml\n")); - REQUIRE(model->name() == "t20020_sequence"); - { - auto src = generate_sequence_puml(diagram, *model); - AliasMatcher _A(src); + // Check if all calls exist + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a1()")); + REQUIRE_THAT( + src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a2()")); + REQUIRE_THAT( + src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a3()")); - REQUIRE_THAT(src, StartsWith("@startuml")); - REQUIRE_THAT(src, EndsWith("@enduml\n")); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b1()")); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b2()")); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "log()")); - // Check if all calls exist - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a1()")); - REQUIRE_THAT( - src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a2()")); - REQUIRE_THAT( - src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a3()")); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("C"), "c1() const")); + REQUIRE_THAT( + src, HasCallInControlCondition(_A("C"), _A("C"), "c2() const")); + REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "log() const")); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b1()")); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b2()")); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "log()")); + REQUIRE_THAT( + src, HasCallInControlCondition(_A("tmain()"), _A("C"), + "c3(int)")); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("C"), "c1() const")); - REQUIRE_THAT( - src, HasCallInControlCondition(_A("C"), _A("C"), "c2() const")); - REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "log() const")); + save_puml(config.output_directory(), diagram->name + ".puml", src); + } - REQUIRE_THAT( - src, HasCallInControlCondition(_A("tmain()"), _A("C"), "c3(int)")); + { + auto j = generate_sequence_json(diagram, *model); - save_puml(config.output_directory(), diagram->name + ".puml", src); - } + using namespace json; - { - auto j = generate_sequence_json(diagram, *model); + std::vector messages = {FindMessage(j, "tmain()", "A", "a1()"), + FindMessage(j, "tmain()", "A", "a5()"), + FindMessage(j, "tmain()", "A", "a2()"), + FindMessage(j, "tmain()", "C", "c3(int)"), + FindMessage(j, "tmain()", "B", "b1()"), + FindMessage(j, "tmain()", "A", "a3()"), + FindMessage(j, "tmain()", "B", "b2()"), + FindMessage(j, "tmain()", "A", "a4()"), + FindMessage(j, "tmain()", "B", "log()"), + FindMessage(j, "tmain()", "C", "c1() const"), + FindMessage(j, "C", "C", "c2() const"), + FindMessage(j, "C", "C", "log() const"), + FindMessage(j, "tmain()", "D", "d1(int,int)")}; - using namespace json; + REQUIRE(std::is_sorted(messages.begin(), messages.end())); - std::vector messages = {FindMessage(j, "tmain()", "A", "a1()"), - FindMessage(j, "tmain()", "A", "a5()"), - FindMessage(j, "tmain()", "A", "a2()"), - FindMessage(j, "tmain()", "C", "c3(int)"), - FindMessage(j, "tmain()", "B", "b1()"), - FindMessage(j, "tmain()", "A", "a3()"), - FindMessage(j, "tmain()", "B", "b2()"), - FindMessage(j, "tmain()", "A", "a4()"), - FindMessage(j, "tmain()", "B", "log()"), - FindMessage(j, "tmain()", "C", "c1() const"), - FindMessage(j, "C", "C", "c2() const"), - FindMessage(j, "C", "C", "log() const"), - FindMessage(j, "tmain()", "D", "d1(int,int)")}; + save_json(config.output_directory(), diagram->name + ".json", j); + } - REQUIRE(std::is_sorted(messages.begin(), messages.end())); + { + auto src = generate_sequence_mermaid(diagram, *model); - save_json(config.output_directory(), diagram->name + ".json", j); - } + mermaid::SequenceDiagramAliasMatcher _A(src); + using mermaid::HasCall; + using mermaid::HasCallInControlCondition; - { - auto src = generate_sequence_mermaid(diagram, *model); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a1()")); + REQUIRE_THAT( + src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a2()")); + REQUIRE_THAT( + src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a3()")); - mermaid::SequenceDiagramAliasMatcher _A(src); - using mermaid::HasCall; - using mermaid::HasCallInControlCondition; + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b1()")); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b2()")); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "log()")); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a1()")); - REQUIRE_THAT( - src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a2()")); - REQUIRE_THAT( - src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a3()")); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("C"), "c1() const")); + REQUIRE_THAT( + src, HasCallInControlCondition(_A("C"), _A("C"), "c2() const")); + REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "log() const")); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b1()")); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b2()")); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "log()")); + REQUIRE_THAT( + src, HasCallInControlCondition(_A("tmain()"), _A("C"), + "c3(int)")); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("C"), "c1() const")); - REQUIRE_THAT( - src, HasCallInControlCondition(_A("C"), _A("C"), "c2() const")); - REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "log() const")); - - REQUIRE_THAT( - src, HasCallInControlCondition(_A("tmain()"), _A("C"), "c3(int)")); - - save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + save_mermaid(config.output_directory(), diagram->name + ".mmd", + src); + } + */ } \ No newline at end of file diff --git a/tests/t20021/test_case.h b/tests/t20021/test_case.h index afcedf98..92e9d1f9 100644 --- a/tests/t20021/test_case.h +++ b/tests/t20021/test_case.h @@ -16,17 +16,31 @@ * limitations under the License. */ -TEST_CASE("t20021", "[test-case][sequence]") +TEST_CASE("t20021") { - auto [config, db] = load_config("t20021"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20021_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20021", "t20021_sequence"); - REQUIRE(diagram->name == "t20021_sequence"); - - auto model = generate_sequence_diagram(*db, diagram); - - REQUIRE(model->name() == "t20021_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain()", "C", "c4()", InControlCondition{}}, // + {"C", "C", "c5()"}, // + {"tmain()", "A", "a3()"}, // + {"tmain()", "A", "a2()", InControlCondition{}}, // + {"tmain()", "C", "c1()", InControlCondition{}}, // + {"tmain()", "C", "c2()", InControlCondition{}}, // + {"tmain()", "A", "a1()"}, // + {"tmain()", "C", "c3()", InControlCondition{}}, // + {"tmain()", "B", "b2() const"}, // + {"tmain()", "C", "contents()", InControlCondition{}}, // + {"tmain()", "B", "b2() const"}, // + })); + }); + /* { auto src = generate_sequence_puml(diagram, *model); AliasMatcher _A(src); @@ -113,5 +127,5 @@ TEST_CASE("t20021", "[test-case][sequence]") HasCallInControlCondition(_A("tmain()"), _A("C"), "contents()")); save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + }*/ } \ No newline at end of file diff --git a/tests/t20022/test_case.h b/tests/t20022/test_case.h index 330e14fa..cdcc5cf4 100644 --- a/tests/t20022/test_case.h +++ b/tests/t20022/test_case.h @@ -16,53 +16,64 @@ * limitations under the License. */ -TEST_CASE("t20022", "[test-case][sequence]") +TEST_CASE("t20022") { - auto [config, db] = load_config("t20022"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20022_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20022", "t20022_sequence"); - REQUIRE(diagram->name == "t20022_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + // TODO: ")" is incorrently rendered by PlantUML + // in a way that ) is bold, if it was ) it's rendered + // properly + {"tmain()", "A", "A(std::unique_ptr)"}, // + {"tmain()", "A", "a()"}, // + {"A", "B", "b()"}, // + })); + }); - auto model = generate_sequence_diagram(*db, diagram); + /* + { + auto src = generate_sequence_puml(diagram, *model); + AliasMatcher _A(src); - REQUIRE(model->name() == "t20022_sequence"); - { - auto src = generate_sequence_puml(diagram, *model); - AliasMatcher _A(src); + REQUIRE_THAT(src, StartsWith("@startuml")); + REQUIRE_THAT(src, EndsWith("@enduml\n")); - REQUIRE_THAT(src, StartsWith("@startuml")); - REQUIRE_THAT(src, EndsWith("@enduml\n")); + // Check if all calls exist + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()")); + REQUIRE_THAT(src, HasCall(_A("A"), _A("B"), "b()")); - // Check if all calls exist - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()")); - REQUIRE_THAT(src, HasCall(_A("A"), _A("B"), "b()")); + save_puml(config.output_directory(), diagram->name + ".puml", src); + } - save_puml(config.output_directory(), diagram->name + ".puml", src); - } + { + auto j = generate_sequence_json(diagram, *model); - { - auto j = generate_sequence_json(diagram, *model); + using namespace json; - using namespace json; + std::vector messages = {FindMessage(j, "tmain()", "A", "a()"), + FindMessage(j, "A", "B", "b()")}; - std::vector messages = {FindMessage(j, "tmain()", "A", "a()"), - FindMessage(j, "A", "B", "b()")}; + REQUIRE(std::is_sorted(messages.begin(), messages.end())); - REQUIRE(std::is_sorted(messages.begin(), messages.end())); + save_json(config.output_directory(), diagram->name + ".json", j); + } - save_json(config.output_directory(), diagram->name + ".json", j); - } + { + auto src = generate_sequence_mermaid(diagram, *model); - { - auto src = generate_sequence_mermaid(diagram, *model); + mermaid::SequenceDiagramAliasMatcher _A(src); + using mermaid::HasCall; - mermaid::SequenceDiagramAliasMatcher _A(src); - using mermaid::HasCall; + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()")); + REQUIRE_THAT(src, HasCall(_A("A"), _A("B"), "b()")); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()")); - REQUIRE_THAT(src, HasCall(_A("A"), _A("B"), "b()")); - - save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + save_mermaid(config.output_directory(), diagram->name + ".mmd", + src); + }*/ } \ No newline at end of file diff --git a/tests/t20023/test_case.h b/tests/t20023/test_case.h index 130d06b8..8a09799c 100644 --- a/tests/t20023/test_case.h +++ b/tests/t20023/test_case.h @@ -16,60 +16,72 @@ * limitations under the License. */ -TEST_CASE("t20023", "[test-case][sequence]") +TEST_CASE("t20023") { - auto [config, db] = load_config("t20023"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20023_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20023", "t20023_sequence"); - REQUIRE(diagram->name == "t20023_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain()", "A", "a()"}, // + {"A", "A", "a2()"}, // + {"A", "A", "a2()"}, // + {"A", "A", "a3()"}, // + {"A", "A", "a4()"}, // - auto model = generate_sequence_diagram(*db, diagram); + })); + }); + /* + { + auto src = generate_sequence_puml(diagram, *model); + AliasMatcher _A(src); - REQUIRE(model->name() == "t20023_sequence"); - { - auto src = generate_sequence_puml(diagram, *model); - AliasMatcher _A(src); + REQUIRE_THAT(src, StartsWith("@startuml")); + REQUIRE_THAT(src, EndsWith("@enduml\n")); - REQUIRE_THAT(src, StartsWith("@startuml")); - REQUIRE_THAT(src, EndsWith("@enduml\n")); + // Check if all calls exist + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()")); + REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a1()")); + REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a2()")); + REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a3()")); + REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a4()")); - // Check if all calls exist - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()")); - REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a1()")); - REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a2()")); - REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a3()")); - REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a4()")); + save_puml(config.output_directory(), diagram->name + ".puml", src); + } - save_puml(config.output_directory(), diagram->name + ".puml", src); - } + { + auto j = generate_sequence_json(diagram, *model); - { - auto j = generate_sequence_json(diagram, *model); + using namespace json; - using namespace json; + std::vector messages = {FindMessage(j, "tmain()", "A", "a()"), + FindMessage(j, "A", "A", "a1()"), FindMessage(j, "A", "A", + "a2()"), FindMessage(j, "A", "A", "a3()"), FindMessage(j, "A", "A", + "a4()")}; - std::vector messages = {FindMessage(j, "tmain()", "A", "a()"), - FindMessage(j, "A", "A", "a1()"), FindMessage(j, "A", "A", "a2()"), - FindMessage(j, "A", "A", "a3()"), FindMessage(j, "A", "A", "a4()")}; + REQUIRE(std::is_sorted(messages.begin(), messages.end())); - REQUIRE(std::is_sorted(messages.begin(), messages.end())); + save_json(config.output_directory(), diagram->name + ".json", j); + } - save_json(config.output_directory(), diagram->name + ".json", j); - } + { + auto src = generate_sequence_mermaid(diagram, *model); - { - auto src = generate_sequence_mermaid(diagram, *model); + mermaid::SequenceDiagramAliasMatcher _A(src); + using mermaid::HasCall; - mermaid::SequenceDiagramAliasMatcher _A(src); - using mermaid::HasCall; + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()")); + REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a1()")); + REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a2()")); + REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a3()")); + REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a4()")); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()")); - REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a1()")); - REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a2()")); - REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a3()")); - REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "a4()")); - - save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + save_mermaid(config.output_directory(), diagram->name + ".mmd", + src); + } + */ } \ No newline at end of file diff --git a/tests/t20024/test_case.h b/tests/t20024/test_case.h index 46d85a0b..72ea1dfd 100644 --- a/tests/t20024/test_case.h +++ b/tests/t20024/test_case.h @@ -16,17 +16,31 @@ * limitations under the License. */ -TEST_CASE("t20024", "[test-case][sequence]") +TEST_CASE("t20024") { - auto [config, db] = load_config("t20024"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20024_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20024", "t20024_sequence"); - REQUIRE(diagram->name == "t20024_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain()", "A", "select(enum_a)"}, // + {"A", "A", "a0()"}, // + {"A", "A", "a1()"}, // + {"A", "A", "a2()"}, // + {"A", "A", "a3()"}, // - auto model = generate_sequence_diagram(*db, diagram); - - REQUIRE(model->name() == "t20024_sequence"); + {"tmain()", "B", "select(colors)"}, // + {"B", "B", "red()"}, // + {"B", "B", "orange()"}, // + {"B", "B", "green()"}, // + {"B", "B", "grey()"} // + })); + }); + /* { auto src = generate_sequence_puml(diagram, *model); AliasMatcher _A(src); @@ -82,5 +96,5 @@ TEST_CASE("t20024", "[test-case][sequence]") REQUIRE_THAT(src, HasCall(_A("B"), _A("B"), "green()")); save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + }*/ } \ No newline at end of file diff --git a/tests/t20025/test_case.h b/tests/t20025/test_case.h index 2875c4f7..432ab52a 100644 --- a/tests/t20025/test_case.h +++ b/tests/t20025/test_case.h @@ -16,17 +16,22 @@ * limitations under the License. */ -TEST_CASE("t20025", "[test-case][sequence]") +TEST_CASE("t20025") { - auto [config, db] = load_config("t20025"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20025_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20025", "t20025_sequence"); - REQUIRE(diagram->name == "t20025_sequence"); - - auto model = generate_sequence_diagram(*db, diagram); - - REQUIRE(model->name() == "t20025_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain()", "A", "a()"}, // + {"tmain()", "add(int,int)", ""} // + })); + }); + /* { auto src = generate_sequence_puml(diagram, *model); AliasMatcher _A(src); @@ -71,5 +76,5 @@ TEST_CASE("t20025", "[test-case][sequence]") REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("add2(int,int)"), "")); save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + }*/ } \ No newline at end of file diff --git a/tests/t20026/test_case.h b/tests/t20026/test_case.h index be0bf34d..44a399ab 100644 --- a/tests/t20026/test_case.h +++ b/tests/t20026/test_case.h @@ -16,17 +16,21 @@ * limitations under the License. */ -TEST_CASE("t20026", "[test-case][sequence]") +TEST_CASE("t20026") { - auto [config, db] = load_config("t20026"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20026_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20026", "t20026_sequence"); - REQUIRE(diagram->name == "t20026_sequence"); - - auto model = generate_sequence_diagram(*db, diagram); - - REQUIRE(model->name() == "t20026_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain()", "A", "a()"} // + })); + }); +/* { auto src = generate_sequence_puml(diagram, *model); AliasMatcher _A(src); @@ -61,5 +65,5 @@ TEST_CASE("t20026", "[test-case][sequence]") REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a()")); save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + }*/ } \ No newline at end of file diff --git a/tests/t20027/test_case.h b/tests/t20027/test_case.h index 97f42249..12d2e962 100644 --- a/tests/t20027/test_case.h +++ b/tests/t20027/test_case.h @@ -16,17 +16,25 @@ * limitations under the License. */ -TEST_CASE("t20027", "[test-case][sequence]") +TEST_CASE("t20027") { - auto [config, db] = load_config("t20027"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20027_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20027", "t20027_sequence"); - REQUIRE(diagram->name == "t20027_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain()", "A", "a()"} // + })); - auto model = generate_sequence_diagram(*db, diagram); + REQUIRE(!HasMessage(src, {"A", "A", "aa()"})); + REQUIRE(!HasMessage(src, {"A", "A", "aaa()"})); + }); - REQUIRE(model->name() == "t20027_sequence"); + /* { auto src = generate_sequence_puml(diagram, *model); AliasMatcher _A(src); @@ -65,5 +73,5 @@ TEST_CASE("t20027", "[test-case][sequence]") REQUIRE_THAT(src, !HasCall(_A("A"), _A("A"), "aaa()")); save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + }*/ } \ No newline at end of file diff --git a/tests/t20028/test_case.h b/tests/t20028/test_case.h index e0947a9f..0f1312ac 100644 --- a/tests/t20028/test_case.h +++ b/tests/t20028/test_case.h @@ -16,17 +16,27 @@ * limitations under the License. */ -TEST_CASE("t20028", "[test-case][sequence]") +TEST_CASE("t20028") { - auto [config, db] = load_config("t20028"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20028_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20028", "t20028_sequence"); - REQUIRE(diagram->name == "t20028_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain()", "A", "a()", InControlCondition{}}, // + {"tmain()", "A", "b()"}, // + {"tmain()", "A", "c()"}, // + {"tmain()", "A", "d()"}, // + })); - auto model = generate_sequence_diagram(*db, diagram); + REQUIRE(!HasMessage(src, {"tmain()", "B", "e()"})); + }); - REQUIRE(model->name() == "t20028_sequence"); + /* { auto src = generate_sequence_puml(diagram, *model); AliasMatcher _A(src); @@ -75,5 +85,5 @@ TEST_CASE("t20028", "[test-case][sequence]") REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("B"), "e()")); save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + }*/ } \ No newline at end of file diff --git a/tests/t20029/test_case.h b/tests/t20029/test_case.h index cfbfc6c4..a03d527e 100644 --- a/tests/t20029/test_case.h +++ b/tests/t20029/test_case.h @@ -16,143 +16,182 @@ * limitations under the License. */ -TEST_CASE("t20029", "[test-case][sequence]") +TEST_CASE("t20029") { - auto [config, db] = load_config("t20029"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20029_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20029", "t20029_sequence"); - REQUIRE(diagram->name == "t20029_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain()", "ConnectionPool", "connect()"}, // + {"tmain()", "Encoder>", + "send(std::string &&)", InControlCondition{}}, // + {"Encoder>", + "Encoder>", + "encode(std::string &&)"}, // + {"Encoder>", + "encode_b64(std::string &&)", ""}, // + {"Encoder>", "Retrier", + "send(std::string &&)"}, // + {"Retrier", "ConnectionPool", + "send(const std::string &)", InControlCondition{}} // + })); - auto model = generate_sequence_diagram(*db, diagram); + REQUIRE(!HasMessage( + src, {"ConnectionPool", "ConnectionPool", "connect_impl()"})); - REQUIRE(model->name() == "t20029_sequence"); - { - auto src = generate_sequence_puml(diagram, *model); - AliasMatcher _A(src); + REQUIRE(HasMessageComment(src, "tmain()", + "Establish connection to the\\n" + "remote server synchronously")); - REQUIRE_THAT(src, StartsWith("@startuml")); - REQUIRE_THAT(src, EndsWith("@enduml\n")); + REQUIRE(HasMessageComment(src, "tmain()", + "Repeat for each line in the\\n" + "input stream")); - // Check if all calls exist - REQUIRE_THAT( - src, HasCall(_A("tmain()"), _A("ConnectionPool"), "connect()")); - REQUIRE_THAT(src, - HasCallInControlCondition(_A("tmain()"), - _A("Encoder>"), - "send(std::string &&)")); + REQUIRE(HasMessageComment(src, "Encoder>", + "Encode the message using\\n" + "Base64 encoding and pass\\n" + "it to the next layer")); - REQUIRE_THAT(src, - HasCall(_A("Encoder>"), - _A("Encoder>"), - "encode(std::string &&)")); + REQUIRE(HasMessageComment(src, "Retrier", + "Repeat until send() succeeds\\n" + "or retry count is exceeded")); + }); + /* + { + auto src = generate_sequence_puml(diagram, *model); + AliasMatcher _A(src); - REQUIRE_THAT(src, - HasCall(_A("Encoder>"), - _A("encode_b64(std::string &&)"), "")); + REQUIRE_THAT(src, StartsWith("@startuml")); + REQUIRE_THAT(src, EndsWith("@enduml\n")); - REQUIRE_THAT(src, - HasCallInControlCondition(_A("Retrier"), - _A("ConnectionPool"), "send(const std::string &)")); + // Check if all calls exist + REQUIRE_THAT( + src, HasCall(_A("tmain()"), _A("ConnectionPool"), "connect()")); + REQUIRE_THAT(src, + HasCallInControlCondition(_A("tmain()"), + _A("Encoder>"), + "send(std::string &&)")); - REQUIRE_THAT(src, - !HasCall( - _A("ConnectionPool"), _A("ConnectionPool"), "connect_impl()")); + REQUIRE_THAT(src, + HasCall(_A("Encoder>"), + _A("Encoder>"), + "encode(std::string &&)")); - REQUIRE_THAT(src, - HasMessageComment(_A("tmain()"), - "Establish connection to the\\n" - "remote server synchronously")); + REQUIRE_THAT(src, + HasCall(_A("Encoder>"), + _A("encode_b64(std::string &&)"), "")); - REQUIRE_THAT(src, - HasMessageComment(_A("tmain()"), - "Repeat for each line in the\\n" - "input stream")); + REQUIRE_THAT(src, + HasCallInControlCondition(_A("Retrier"), + _A("ConnectionPool"), "send(const std::string &)")); - REQUIRE_THAT(src, - HasMessageComment(_A("Encoder>"), - "Encode the message using\\n" - "Base64 encoding and pass\\n" - "it to the next layer")); + REQUIRE_THAT(src, + !HasCall( + _A("ConnectionPool"), _A("ConnectionPool"), + "connect_impl()")); - REQUIRE_THAT(src, - HasMessageComment(_A("Retrier"), - "Repeat until send\\(\\) succeeds\\n" - "or retry count is exceeded")); + REQUIRE_THAT(src, + HasMessageComment(_A("tmain()"), + "Establish connection to the\\n" + "remote server synchronously")); - save_puml(config.output_directory(), diagram->name + ".puml", src); - } + REQUIRE_THAT(src, + HasMessageComment(_A("tmain()"), + "Repeat for each line in the\\n" + "input stream")); - { - auto j = generate_sequence_json(diagram, *model); + REQUIRE_THAT(src, + HasMessageComment(_A("Encoder>"), + "Encode the message using\\n" + "Base64 encoding and pass\\n" + "it to the next layer")); - using namespace json; + REQUIRE_THAT(src, + HasMessageComment(_A("Retrier"), + "Repeat until send\\(\\) succeeds\\n" + "or retry count is exceeded")); - REQUIRE(!j["participants"].is_null()); + save_puml(config.output_directory(), diagram->name + ".puml", src); + } - std::vector messages = { - FindMessage(j, "tmain()", "ConnectionPool", "connect()"), - FindMessage(j, "tmain()", "Encoder>", - "send(std::string &&)")}; + { + auto j = generate_sequence_json(diagram, *model); - REQUIRE(std::is_sorted(messages.begin(), messages.end())); + using namespace json; - save_json(config.output_directory(), diagram->name + ".json", j); - } + REQUIRE(!j["participants"].is_null()); - { - auto src = generate_sequence_mermaid(diagram, *model); + std::vector messages = { + FindMessage(j, "tmain()", "ConnectionPool", "connect()"), + FindMessage(j, "tmain()", "Encoder>", + "send(std::string &&)")}; - mermaid::SequenceDiagramAliasMatcher _A(src); - using mermaid::HasCall; - using mermaid::HasCallInControlCondition; - using mermaid::HasMessageComment; + REQUIRE(std::is_sorted(messages.begin(), messages.end())); - REQUIRE_THAT( - src, HasCall(_A("tmain()"), _A("ConnectionPool"), "connect()")); - REQUIRE_THAT(src, - HasCallInControlCondition(_A("tmain()"), - _A("Encoder>"), - "send(std::string &&)")); + save_json(config.output_directory(), diagram->name + ".json", j); + } - REQUIRE_THAT(src, - HasCall(_A("Encoder>"), - _A("Encoder>"), - "encode(std::string &&)")); + { + auto src = generate_sequence_mermaid(diagram, *model); - REQUIRE_THAT(src, - HasCall(_A("Encoder>"), - _A("encode_b64(std::string &&)"), "")); + mermaid::SequenceDiagramAliasMatcher _A(src); + using mermaid::HasCall; + using mermaid::HasCallInControlCondition; + using mermaid::HasMessageComment; - REQUIRE_THAT(src, - HasCallInControlCondition(_A("Retrier"), - _A("ConnectionPool"), "send(const std::string &)")); + REQUIRE_THAT( + src, HasCall(_A("tmain()"), _A("ConnectionPool"), "connect()")); + REQUIRE_THAT(src, + HasCallInControlCondition(_A("tmain()"), + _A("Encoder>"), + "send(std::string &&)")); - REQUIRE_THAT(src, - !HasCall( - _A("ConnectionPool"), _A("ConnectionPool"), "connect_impl()")); + REQUIRE_THAT(src, + HasCall(_A("Encoder>"), + _A("Encoder>"), + "encode(std::string &&)")); - REQUIRE_THAT(src, - HasMessageComment(_A("tmain()"), - "Establish connection to the
" - "remote server synchronously")); + REQUIRE_THAT(src, + HasCall(_A("Encoder>"), + _A("encode_b64(std::string &&)"), "")); - REQUIRE_THAT(src, - HasMessageComment(_A("tmain()"), - "Repeat for each line in the
" - "input stream")); + REQUIRE_THAT(src, + HasCallInControlCondition(_A("Retrier"), + _A("ConnectionPool"), "send(const std::string &)")); - REQUIRE_THAT(src, - HasMessageComment(_A("Encoder>"), - "Encode the message using
" - "Base64 encoding and pass
" - "it to the next layer")); + REQUIRE_THAT(src, + !HasCall( + _A("ConnectionPool"), _A("ConnectionPool"), + "connect_impl()")); - REQUIRE_THAT(src, - HasMessageComment(_A("Retrier"), - "Repeat until send\\(\\) succeeds
" - "or retry count is exceeded")); + REQUIRE_THAT(src, + HasMessageComment(_A("tmain()"), + "Establish connection to the
" + "remote server synchronously")); - save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + REQUIRE_THAT(src, + HasMessageComment(_A("tmain()"), + "Repeat for each line in the
" + "input stream")); + + REQUIRE_THAT(src, + HasMessageComment(_A("Encoder>"), + "Encode the message using
" + "Base64 encoding and pass
" + "it to the next layer")); + + REQUIRE_THAT(src, + HasMessageComment(_A("Retrier"), + "Repeat until send\\(\\) succeeds
" + "or retry count is exceeded")); + + save_mermaid(config.output_directory(), diagram->name + ".mmd", + src); + } + */ } \ No newline at end of file diff --git a/tests/t20030/test_case.h b/tests/t20030/test_case.h index fdda6293..c2b8fefb 100644 --- a/tests/t20030/test_case.h +++ b/tests/t20030/test_case.h @@ -16,75 +16,93 @@ * limitations under the License. */ -TEST_CASE("t20030", "[test-case][sequence]") +TEST_CASE("t20030") { - auto [config, db] = load_config("t20030"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20030_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20030", "t20030_sequence"); - REQUIRE(diagram->name == "t20030_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain(int)", "magic()", ""}, // + {"tmain(int)", "A", "A(int)"}, // + {"tmain(int)", "A", "operator+=(int)"}, // + {"A", "A", "add(int)"}, // + {"tmain(bool,int)", "A", "A()"}, // + // {"A", "A", "create()"}, // + // {"tmain(bool,int)", "A", "A()"}, // + // {"A", "A", "create()"}, // + // {"tmain(bool,int)", "A", "operator+=(int)"}, + // // + // {"A", "A", "add(int)"}, // + // {"tmain(bool,int)", "A", "operator=(const A + // &)"}, // + // {"A", "A", "set(int)"}, // + // {"tmain(bool,int)", "A", "value() const"} // + })); + }); + /* + { + auto src = generate_sequence_puml(diagram, *model); + AliasMatcher _A(src); - auto model = generate_sequence_diagram(*db, diagram); + REQUIRE_THAT(src, StartsWith("@startuml")); + REQUIRE_THAT(src, EndsWith("@enduml\n")); - REQUIRE(model->name() == "t20030_sequence"); + // Check if all calls exist + REQUIRE_THAT(src, HasCall(_A("tmain(int)"), _A("magic()"), "")); - { - auto src = generate_sequence_puml(diagram, *model); - AliasMatcher _A(src); + REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "create()")); + REQUIRE_THAT( + src, HasCall(_A("tmain(int)"), _A("A"), "operator+=(int)")); + REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "add(int)")); - REQUIRE_THAT(src, StartsWith("@startuml")); - REQUIRE_THAT(src, EndsWith("@enduml\n")); + REQUIRE_THAT(src, HasCall(_A("tmain(bool,int)"), _A("A"), "A()")); + REQUIRE_THAT( + src, HasCall(_A("tmain(bool,int)"), _A("A"), + "operator+=(int)")); REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), + "add(int)")); REQUIRE_THAT(src, HasCall(_A("tmain(bool,int)"), _A("A"), + "operator=(const A &)")); REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), + "set(int)")); REQUIRE_THAT(src, HasCall(_A("tmain(bool,int)"), _A("A"), + "value()")); - // Check if all calls exist - REQUIRE_THAT(src, HasCall(_A("tmain(int)"), _A("magic()"), "")); + save_puml(config.output_directory(), diagram->name + ".puml", src); + } - REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "create()")); - REQUIRE_THAT( - src, HasCall(_A("tmain(int)"), _A("A"), "operator+=(int)")); - REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "add(int)")); + { + auto j = generate_sequence_json(diagram, *model); - REQUIRE_THAT(src, HasCall(_A("tmain(bool,int)"), _A("A"), "A()")); - REQUIRE_THAT( - src, HasCall(_A("tmain(bool,int)"), _A("A"), "operator+=(int)")); - REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "add(int)")); - REQUIRE_THAT(src, - HasCall(_A("tmain(bool,int)"), _A("A"), "operator=(const A &)")); - REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "set(int)")); - REQUIRE_THAT(src, HasCall(_A("tmain(bool,int)"), _A("A"), "value()")); + using namespace json; - save_puml(config.output_directory(), diagram->name + ".puml", src); - } + save_json(config.output_directory(), diagram->name + ".json", j); + } - { - auto j = generate_sequence_json(diagram, *model); + { + auto src = generate_sequence_mermaid(diagram, *model); - using namespace json; + mermaid::SequenceDiagramAliasMatcher _A(src); + using mermaid::HasCall; - save_json(config.output_directory(), diagram->name + ".json", j); - } + REQUIRE_THAT(src, HasCall(_A("tmain(int)"), _A("magic()"), "")); - { - auto src = generate_sequence_mermaid(diagram, *model); + REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "create()")); + REQUIRE_THAT( + src, HasCall(_A("tmain(int)"), _A("A"), "operator+=(int)")); + REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "add(int)")); - mermaid::SequenceDiagramAliasMatcher _A(src); - using mermaid::HasCall; + REQUIRE_THAT(src, HasCall(_A("tmain(bool,int)"), _A("A"), "A()")); + REQUIRE_THAT( + src, HasCall(_A("tmain(bool,int)"), _A("A"), + "operator+=(int)")); REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), + "add(int)")); REQUIRE_THAT(src, HasCall(_A("tmain(bool,int)"), _A("A"), + "operator=(const A &)")); REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), + "set(int)")); REQUIRE_THAT(src, HasCall(_A("tmain(bool,int)"), _A("A"), + "value()")); - REQUIRE_THAT(src, HasCall(_A("tmain(int)"), _A("magic()"), "")); - - REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "create()")); - REQUIRE_THAT( - src, HasCall(_A("tmain(int)"), _A("A"), "operator+=(int)")); - REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "add(int)")); - - REQUIRE_THAT(src, HasCall(_A("tmain(bool,int)"), _A("A"), "A()")); - REQUIRE_THAT( - src, HasCall(_A("tmain(bool,int)"), _A("A"), "operator+=(int)")); - REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "add(int)")); - REQUIRE_THAT(src, - HasCall(_A("tmain(bool,int)"), _A("A"), "operator=(const A &)")); - REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "set(int)")); - REQUIRE_THAT(src, HasCall(_A("tmain(bool,int)"), _A("A"), "value()")); - - save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + save_mermaid(config.output_directory(), diagram->name + ".mmd", + src); + }*/ } \ No newline at end of file diff --git a/tests/t20031/test_case.h b/tests/t20031/test_case.h index f325cb53..4fd9c885 100644 --- a/tests/t20031/test_case.h +++ b/tests/t20031/test_case.h @@ -16,18 +16,23 @@ * limitations under the License. */ -TEST_CASE("t20031", "[test-case][sequence]") +TEST_CASE("t20031") { - auto [config, db] = load_config("t20031"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20031_sequence"]; - - REQUIRE(diagram->name == "t20031_sequence"); - - auto model = generate_sequence_diagram(*db, diagram); - - REQUIRE(model->name() == "t20031_sequence"); + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20031", "t20031_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain(int)", "magic()", ""}, // + {"tmain(bool,int)", "execute(std::function)", ""}, // + {"tmain(bool,int)", "A", "value() const"} // + })); + }); +/* { auto src = generate_sequence_puml(diagram, *model); AliasMatcher _A(src); @@ -94,4 +99,5 @@ TEST_CASE("t20031", "[test-case][sequence]") save_mermaid(config.output_directory(), diagram->name + ".mmd", src); } -} \ No newline at end of file +*/ + } \ No newline at end of file diff --git a/tests/t20032/test_case.h b/tests/t20032/test_case.h index c056ed62..5a52d3ea 100644 --- a/tests/t20032/test_case.h +++ b/tests/t20032/test_case.h @@ -16,19 +16,34 @@ * limitations under the License. */ -TEST_CASE("t20032", "[test-case][sequence]") +TEST_CASE("t20032") { - auto [config, db] = load_config("t20032"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20032_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20032", "t20032_sequence"); - REQUIRE(diagram->name == "t20032_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain(int,char **)", "B", "b(int)"}, // + {"B", "A", "a1(int)"}, // + {"A", "B", "int", Response{}}, // + {"B", "tmain(int,char **)", "int", Response{}}, // - auto model = generate_sequence_diagram(*db, diagram); + {"tmain(int,char **)", "B", "b(double)"}, // + {"B", "A", "a2(double)"}, // + {"A", "B", "double", Response{}}, // + {"B", "tmain(int,char **)", "double", Response{}}, // - REQUIRE(model->name() == "t20032_sequence"); - - REQUIRE(model->name() == "t20032_sequence"); + {"tmain(int,char **)", "B", "b(const char *)"}, // + {"B", "A", "a3(const char *)"}, // + {"A", "B", "const char *", Response{}}, // + {"B", "tmain(int,char **)", "const char *", Response{}} // + })); + }); + /* { auto src = generate_sequence_puml(diagram, *model); AliasMatcher _A(src); @@ -100,5 +115,5 @@ TEST_CASE("t20032", "[test-case][sequence]") REQUIRE_THAT(src, HasResponse(_A("B"), _A("A"), "const char *")); save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + }*/ } \ No newline at end of file diff --git a/tests/t20033/test_case.h b/tests/t20033/test_case.h index f1f10c63..172f9076 100644 --- a/tests/t20033/test_case.h +++ b/tests/t20033/test_case.h @@ -16,60 +16,86 @@ * limitations under the License. */ -TEST_CASE("t20033", "[test-case][sequence]") +TEST_CASE("t20033") { - auto [config, db] = load_config("t20033"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20033_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20033", "t20033_sequence"); - REQUIRE(diagram->name == "t20033_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain()", "A", "a1()"}, // + {"tmain()", "A", "a2()"}, // + {"tmain()", "A", "a2()", InControlCondition{}}, // + {"tmain()", "A", "a3()", InControlCondition{}}, // + {"tmain()", "A", "a3()"}, // + {"tmain()", "A", "a4()"}, // - auto model = generate_sequence_diagram(*db, diagram); + {"tmain()", "A", "a2()", InControlCondition{}}, // + {"tmain()", "A", "a3()"}, // - REQUIRE(model->name() == "t20033_sequence"); + {"tmain()", "A", "a2()", InControlCondition{}}, // + {"tmain()", "A", "a3()"}, // - { - auto src = generate_sequence_puml(diagram, *model); - AliasMatcher _A(src); + {"tmain()", "A", "a3()"}, // - REQUIRE_THAT(src, StartsWith("@startuml")); - REQUIRE_THAT(src, EndsWith("@enduml\n")); + {"tmain()", "A", "a2()"}, // - // Check if all calls exist - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a1()")); - REQUIRE_THAT( - src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a2()")); - REQUIRE_THAT( - src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a3()")); - REQUIRE_THAT( - src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a4()")); + {"tmain()", "A", "a4()"}, // + {"tmain()", "A", "a3()", InControlCondition{}}, // - save_puml(config.output_directory(), diagram->name + ".puml", src); - } + {"tmain()", "A", "a4()", InControlCondition{}}, // - { - auto j = generate_sequence_json(diagram, *model); + {"tmain()", "A", "a4()"} // + })); + }); + /* + { + auto src = generate_sequence_puml(diagram, *model); + AliasMatcher _A(src); - using namespace json; + REQUIRE_THAT(src, StartsWith("@startuml")); + REQUIRE_THAT(src, EndsWith("@enduml\n")); - save_json(config.output_directory(), diagram->name + ".json", j); - } + // Check if all calls exist + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a1()")); + REQUIRE_THAT( + src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a2()")); + REQUIRE_THAT( + src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a3()")); + REQUIRE_THAT( + src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a4()")); - { - auto src = generate_sequence_mermaid(diagram, *model); + save_puml(config.output_directory(), diagram->name + ".puml", src); + } - mermaid::SequenceDiagramAliasMatcher _A(src); - using mermaid::HasCall; - using mermaid::HasCallInControlCondition; + { + auto j = generate_sequence_json(diagram, *model); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a1()")); - REQUIRE_THAT( - src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a2()")); - REQUIRE_THAT( - src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a3()")); - REQUIRE_THAT( - src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a4()")); + using namespace json; - save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + save_json(config.output_directory(), diagram->name + ".json", j); + } + + { + auto src = generate_sequence_mermaid(diagram, *model); + + mermaid::SequenceDiagramAliasMatcher _A(src); + using mermaid::HasCall; + using mermaid::HasCallInControlCondition; + + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("A"), "a1()")); + REQUIRE_THAT( + src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a2()")); + REQUIRE_THAT( + src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a3()")); + REQUIRE_THAT( + src, HasCallInControlCondition(_A("tmain()"), _A("A"), "a4()")); + + save_mermaid(config.output_directory(), diagram->name + ".mmd", + src); + }*/ } \ No newline at end of file diff --git a/tests/t20034/test_case.h b/tests/t20034/test_case.h index 26290368..49af0319 100644 --- a/tests/t20034/test_case.h +++ b/tests/t20034/test_case.h @@ -16,79 +16,127 @@ * limitations under the License. */ -TEST_CASE("t20034", "[test-case][sequence]") +TEST_CASE("t20034") { - auto [config, db] = load_config("t20034"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20034_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20034", "t20034_sequence"); - REQUIRE(diagram->name == "t20034_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageChainsOrder(src, + { + // + { + // + {Entrypoint{}, "D", "d2()"}, // + {"D", "C", "c2()"}, // + {"C", "B", "b2()"}, // + {"B", "A", "a2()"} // + }, // + { + // + {Entrypoint{}, "D", "d2()"}, // + {"D", "D::d2()::(lambda t20034.cc:56:18)", + "operator()() const"}, // + {"D::d2()::(lambda t20034.cc:56:18)", "A", "a2()"} // + }, // + { + // + {Entrypoint{}, "D", "d2()"}, // + {"D", "A", "a2()"} // + }, // + { + // + {Entrypoint{}, "D", "d2()"}, // + {"D", "C", "c4()"}, // + {"C", "B", "b4()"}, // + {"B", "B", "b2()"}, // + {"B", "A", "a2()"} // + }, // + { + // + {Entrypoint{}, "D", "d2()"}, // + {"D", "C", "c1()"}, // + {"C", "B", "b1()"}, // + {"B", "A", "a2()"} // + }, // + { + // + {Entrypoint{}, "D", "d2()"}, // + {"D", "C", "c3()"}, // + {"C", "C", "c2()"}, // + {"C", "B", "b2()"}, // + {"B", "A", "a2()"} // + } // + })); + }); + /* + { + auto src = generate_sequence_puml(diagram, *model); + AliasMatcher _A(src); - auto model = generate_sequence_diagram(*db, diagram); + REQUIRE_THAT(src, StartsWith("@startuml")); + REQUIRE_THAT(src, EndsWith("@enduml\n")); - REQUIRE(model->name() == "t20034_sequence"); + // Check if all calls exist + REQUIRE_THAT(src, HasCall(_A("D"), _A("A"), "a2()")); - { - auto src = generate_sequence_puml(diagram, *model); - AliasMatcher _A(src); + REQUIRE_THAT(src, HasCall(_A("D"), _A("C"), "c3()")); + REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "c2()")); + REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()")); + REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()")); - REQUIRE_THAT(src, StartsWith("@startuml")); - REQUIRE_THAT(src, EndsWith("@enduml\n")); + REQUIRE_THAT(src, HasCall(_A("D"), _A("C"), "c4()")); - // Check if all calls exist - REQUIRE_THAT(src, HasCall(_A("D"), _A("A"), "a2()")); + REQUIRE_THAT(src, !HasCall(_A("C"), _A("B"), "b3()")); - REQUIRE_THAT(src, HasCall(_A("D"), _A("C"), "c3()")); - REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "c2()")); - REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()")); + save_puml(config.output_directory(), diagram->name + + ".puml", src); + } - REQUIRE_THAT(src, HasCall(_A("D"), _A("C"), "c4()")); + { + auto j = generate_sequence_json(diagram, *model); - REQUIRE_THAT(src, !HasCall(_A("C"), _A("B"), "b3()")); + using namespace json; - save_puml(config.output_directory(), diagram->name + ".puml", src); - } + REQUIRE(HasMessageChain(j, + {{"d2()", "c3()", "void"}, {"c3()", "c2()", "void"}, + {"c2()", "b2()", "void"}, {"b2()", "a2()", + "void"}})); REQUIRE(HasMessageChain(j, + {{"d2()", "c4()", "void"}, {"c4()", "b4()", "void"}, + {"b4()", "b2()", "void"}, {"b2()", "a2()", + "void"}})); REQUIRE(HasMessageChain(j, {{"d2()", "a2()", + "void"}})); REQUIRE(HasMessageChain(j, + {{"d2()", "c1()", "void"}, {"c1()", "b1()", "void"}, + {"b1()", "a2()", "void"}})); + REQUIRE(HasMessageChain(j, + {{"d2()", "c2()", "void"}, {"c2()", "b2()", "void"}, + {"b2()", "a2()", "void"}})); - { - auto j = generate_sequence_json(diagram, *model); + save_json(config.output_directory(), diagram->name + + ".json", j); + } - using namespace json; + { + auto src = generate_sequence_mermaid(diagram, *model); - REQUIRE(HasMessageChain(j, - {{"d2()", "c3()", "void"}, {"c3()", "c2()", "void"}, - {"c2()", "b2()", "void"}, {"b2()", "a2()", "void"}})); - REQUIRE(HasMessageChain(j, - {{"d2()", "c4()", "void"}, {"c4()", "b4()", "void"}, - {"b4()", "b2()", "void"}, {"b2()", "a2()", "void"}})); - REQUIRE(HasMessageChain(j, {{"d2()", "a2()", "void"}})); - REQUIRE(HasMessageChain(j, - {{"d2()", "c1()", "void"}, {"c1()", "b1()", "void"}, - {"b1()", "a2()", "void"}})); - REQUIRE(HasMessageChain(j, - {{"d2()", "c2()", "void"}, {"c2()", "b2()", "void"}, - {"b2()", "a2()", "void"}})); + mermaid::SequenceDiagramAliasMatcher _A(src); + using mermaid::HasCall; - save_json(config.output_directory(), diagram->name + ".json", j); - } + REQUIRE_THAT(src, HasCall(_A("D"), _A("A"), "a2()")); - { - auto src = generate_sequence_mermaid(diagram, *model); + REQUIRE_THAT(src, HasCall(_A("D"), _A("C"), "c3()")); + REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "c2()")); + REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()")); + REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()")); - mermaid::SequenceDiagramAliasMatcher _A(src); - using mermaid::HasCall; + REQUIRE_THAT(src, HasCall(_A("D"), _A("C"), "c4()")); - REQUIRE_THAT(src, HasCall(_A("D"), _A("A"), "a2()")); + REQUIRE_THAT(src, !HasCall(_A("C"), _A("B"), "b3()")); - REQUIRE_THAT(src, HasCall(_A("D"), _A("C"), "c3()")); - REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "c2()")); - REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()")); - - REQUIRE_THAT(src, HasCall(_A("D"), _A("C"), "c4()")); - - REQUIRE_THAT(src, !HasCall(_A("C"), _A("B"), "b3()")); - - save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + save_mermaid(config.output_directory(), diagram->name + + ".mmd", src); + } + */ } \ No newline at end of file diff --git a/tests/t20035/test_case.h b/tests/t20035/test_case.h index 8213597d..d04ce96c 100644 --- a/tests/t20035/test_case.h +++ b/tests/t20035/test_case.h @@ -16,54 +16,62 @@ * limitations under the License. */ -TEST_CASE("t20035", "[test-case][sequence]") +TEST_CASE("t20035") { - auto [config, db] = load_config("t20035"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20035_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20035", "t20035_sequence"); - REQUIRE(diagram->name == "t20035_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageChainsOrder(src, + {{ + // + {"tmain(int,char **)", "a(int)", ""}, // + {"a(int)", "b1(int)", ""}, // + {"b1(int)", "c(int)", ""} // + }})); + }); + /* + { + auto src = generate_sequence_puml(diagram, *model); + AliasMatcher _A(src); - auto model = generate_sequence_diagram(*db, diagram); + REQUIRE_THAT(src, StartsWith("@startuml")); + REQUIRE_THAT(src, EndsWith("@enduml\n")); - REQUIRE(model->name() == "t20035_sequence"); + REQUIRE_THAT(src, HasCall(_A("tmain(int,char **)"), _A("a(int)"), + "")); REQUIRE_THAT(src, HasCall(_A("a(int)"), _A("b1(int)"), "")); + REQUIRE_THAT(src, HasCall(_A("b1(int)"), _A("c(int)"), "")); - { - auto src = generate_sequence_puml(diagram, *model); - AliasMatcher _A(src); + save_puml(config.output_directory(), diagram->name + ".puml", src); + } - REQUIRE_THAT(src, StartsWith("@startuml")); - REQUIRE_THAT(src, EndsWith("@enduml\n")); + { + auto j = generate_sequence_json(diagram, *model); - REQUIRE_THAT(src, HasCall(_A("tmain(int,char **)"), _A("a(int)"), "")); - REQUIRE_THAT(src, HasCall(_A("a(int)"), _A("b1(int)"), "")); - REQUIRE_THAT(src, HasCall(_A("b1(int)"), _A("c(int)"), "")); + using namespace json; - save_puml(config.output_directory(), diagram->name + ".puml", src); - } + REQUIRE(HasMessageChain(j, + {{"tmain(int,char **)", "a(int)", "int"}, + {"a(int)", "b1(int)", "int"}, {"b1(int)", "c(int)", + "int"}})); - { - auto j = generate_sequence_json(diagram, *model); + save_json(config.output_directory(), diagram->name + ".json", j); + } - using namespace json; + { + auto src = generate_sequence_mermaid(diagram, *model); - REQUIRE(HasMessageChain(j, - {{"tmain(int,char **)", "a(int)", "int"}, - {"a(int)", "b1(int)", "int"}, {"b1(int)", "c(int)", "int"}})); + mermaid::SequenceDiagramAliasMatcher _A(src); + using mermaid::HasCall; - save_json(config.output_directory(), diagram->name + ".json", j); - } + REQUIRE_THAT(src, HasCall(_A("tmain(int,char **)"), _A("a(int)"), + "")); REQUIRE_THAT(src, HasCall(_A("a(int)"), _A("b1(int)"), "")); + REQUIRE_THAT(src, HasCall(_A("b1(int)"), _A("c(int)"), "")); - { - auto src = generate_sequence_mermaid(diagram, *model); - - mermaid::SequenceDiagramAliasMatcher _A(src); - using mermaid::HasCall; - - REQUIRE_THAT(src, HasCall(_A("tmain(int,char **)"), _A("a(int)"), "")); - REQUIRE_THAT(src, HasCall(_A("a(int)"), _A("b1(int)"), "")); - REQUIRE_THAT(src, HasCall(_A("b1(int)"), _A("c(int)"), "")); - - save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + save_mermaid(config.output_directory(), diagram->name + ".mmd", + src); + } + */ } \ No newline at end of file diff --git a/tests/t20036/test_case.h b/tests/t20036/test_case.h index f8da4cd2..27819a5a 100644 --- a/tests/t20036/test_case.h +++ b/tests/t20036/test_case.h @@ -16,78 +16,119 @@ * limitations under the License. */ -TEST_CASE("t20036", "[test-case][sequence]") +TEST_CASE("t20036") { - auto [config, db] = load_config("t20036"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20036_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20036", "t20036_sequence"); - REQUIRE(diagram->name == "t20036_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageChainsOrder(src, + { + // + { + // + {Entrypoint{}, "C", "c1()"}, // + {"C", "B", "b1()"}, // + {"B", "A", "a2()"}, // + }, // + { + // + {Entrypoint{}, "D", "d1()"}, // + {"D", "C", "c2()"}, // + {"C", "B", "b2()"}, // + {"B", "A", "a2()"}, // + }, // + { + // + {Entrypoint{}, "D", "d3()"}, // + {"D", "A", "a2()"}, // + }, // + { + // + {Entrypoint{}, "C", "c4()"}, // + {"C", "B", "b2()"}, // + {"B", "A", "a2()"}, // + }, // + { + // + {Entrypoint{}, "C", "c3()"}, // + {"C", "C", "c2()"}, // + {"C", "B", "b2()"}, // + {"B", "A", "a2()"}, // + }, // + { + // + {Entrypoint{}, "D", "d2()"}, // + {"D", "C", "c2()"}, // + {"C", "B", "b2()"}, // + {"B", "A", "a2()"}, // + }, // + })); + }); + /* + { + auto src = generate_sequence_puml(diagram, *model); + AliasMatcher _A(src); - auto model = generate_sequence_diagram(*db, diagram); + REQUIRE_THAT(src, StartsWith("@startuml")); + REQUIRE_THAT(src, EndsWith("@enduml\n")); - REQUIRE(model->name() == "t20036_sequence"); + REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "c2()")); + REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()")); + REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()")); - { - auto src = generate_sequence_puml(diagram, *model); - AliasMatcher _A(src); + REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()")); + REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()")); - REQUIRE_THAT(src, StartsWith("@startuml")); - REQUIRE_THAT(src, EndsWith("@enduml\n")); + REQUIRE_THAT(src, HasCall(_A("D"), _A("A"), "a2()")); - REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "c2()")); - REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()")); + REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b1()")); + REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()")); - REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()")); + save_puml(config.output_directory(), diagram->name + ".puml", src); + } - REQUIRE_THAT(src, HasCall(_A("D"), _A("A"), "a2()")); + { + auto j = generate_sequence_json(diagram, *model); - REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b1()")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()")); + using namespace json; - save_puml(config.output_directory(), diagram->name + ".puml", src); - } + REQUIRE(HasMessageChain(j, + {{"c3()", "c2()", "void"}, {"c2()", "b2()", "void"}, + {"b2()", "a2()", "void"}})); + REQUIRE(HasMessageChain( + j, {{"c4()", "b2()", "void"}, {"b2()", "a2()", "void"}})); + REQUIRE(HasMessageChain(j, {{"d3()", "a2()", "void"}})); + REQUIRE(HasMessageChain(j, + {{"d1()", "c2()", "void"}, {"c2()", "b2()", "void"}, + {"b2()", "a2()", "void"}})); + REQUIRE(HasMessageChain( + j, {{"c1()", "b1()", "void"}, {"b1()", "a2()", "void"}})); - { - auto j = generate_sequence_json(diagram, *model); + save_json(config.output_directory(), diagram->name + ".json", j); + } - using namespace json; + { + auto src = generate_sequence_mermaid(diagram, *model); - REQUIRE(HasMessageChain(j, - {{"c3()", "c2()", "void"}, {"c2()", "b2()", "void"}, - {"b2()", "a2()", "void"}})); - REQUIRE(HasMessageChain( - j, {{"c4()", "b2()", "void"}, {"b2()", "a2()", "void"}})); - REQUIRE(HasMessageChain(j, {{"d3()", "a2()", "void"}})); - REQUIRE(HasMessageChain(j, - {{"d1()", "c2()", "void"}, {"c2()", "b2()", "void"}, - {"b2()", "a2()", "void"}})); - REQUIRE(HasMessageChain( - j, {{"c1()", "b1()", "void"}, {"b1()", "a2()", "void"}})); + mermaid::SequenceDiagramAliasMatcher _A(src); + using mermaid::HasCall; - save_json(config.output_directory(), diagram->name + ".json", j); - } + REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "c2()")); + REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()")); + REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()")); - { - auto src = generate_sequence_mermaid(diagram, *model); + REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()")); + REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()")); - mermaid::SequenceDiagramAliasMatcher _A(src); - using mermaid::HasCall; + REQUIRE_THAT(src, HasCall(_A("D"), _A("A"), "a2()")); - REQUIRE_THAT(src, HasCall(_A("C"), _A("C"), "c2()")); - REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()")); + REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b1()")); + REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()")); - REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b2()")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()")); - - REQUIRE_THAT(src, HasCall(_A("D"), _A("A"), "a2()")); - - REQUIRE_THAT(src, HasCall(_A("C"), _A("B"), "b1()")); - REQUIRE_THAT(src, HasCall(_A("B"), _A("A"), "a2()")); - - save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + save_mermaid(config.output_directory(), diagram->name + ".mmd", + src); + }*/ } \ No newline at end of file diff --git a/tests/t20037/test_case.h b/tests/t20037/test_case.h index 15f20df3..a5d6efbf 100644 --- a/tests/t20037/test_case.h +++ b/tests/t20037/test_case.h @@ -16,60 +16,76 @@ * limitations under the License. */ -TEST_CASE("t20037", "[test-case][sequence]") +TEST_CASE("t20037") { - auto [config, db] = load_config("t20037"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20037_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20037", "t20037_sequence"); - REQUIRE(diagram->name == "t20037_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain(int,char **)", "a()", ""}, // + {"a()", "A", "A()"}, // + {"a()", "initb()", ""}, // + {"a()", "B", "get()"}, // + {"a()", "c()", ""}, // - auto model = generate_sequence_diagram(*db, diagram); +// {"tmain(int,char **)", "a()", ""}, // +// {"a()", "B", "get()"}, // +// {"a()", "c()", ""}, // +// +// {"tmain(int,char **)", "a()", ""}, // +// {"a()", "B", "get()"}, // +// {"a()", "c()", ""} // + })); + }); + /* + { + auto src = generate_sequence_puml(diagram, *model); + AliasMatcher _A(src); - REQUIRE(model->name() == "t20037_sequence"); + REQUIRE_THAT(src, StartsWith("@startuml")); + REQUIRE_THAT(src, EndsWith("@enduml\n")); - { - auto src = generate_sequence_puml(diagram, *model); - AliasMatcher _A(src); + REQUIRE_THAT(src, HasCall(_A("tmain(int,char **)"), _A("a()"), "")); + REQUIRE_THAT(src, HasCall(_A("a()"), _A("initb()"), "")); + REQUIRE_THAT(src, HasCall(_A("a()"), _A("B"), "get()")); + REQUIRE_THAT(src, HasCall(_A("a()"), _A("c()"), "")); - REQUIRE_THAT(src, StartsWith("@startuml")); - REQUIRE_THAT(src, EndsWith("@enduml\n")); + save_puml(config.output_directory(), diagram->name + ".puml", src); + } - REQUIRE_THAT(src, HasCall(_A("tmain(int,char **)"), _A("a()"), "")); - REQUIRE_THAT(src, HasCall(_A("a()"), _A("initb()"), "")); - REQUIRE_THAT(src, HasCall(_A("a()"), _A("B"), "get()")); - REQUIRE_THAT(src, HasCall(_A("a()"), _A("c()"), "")); + { + auto j = generate_sequence_json(diagram, *model); - save_puml(config.output_directory(), diagram->name + ".puml", src); - } + using namespace json; - { - auto j = generate_sequence_json(diagram, *model); + std::vector messages = { + FindMessage(j, "tmain(int,char **)", "a()", ""), + FindMessage(j, "a()", "initb()", ""), + FindMessage(j, "a()", "B", "get()"), + FindMessage(j, "a()", "c()", "")}; - using namespace json; + REQUIRE(std::is_sorted(messages.begin(), messages.end())); - std::vector messages = { - FindMessage(j, "tmain(int,char **)", "a()", ""), - FindMessage(j, "a()", "initb()", ""), - FindMessage(j, "a()", "B", "get()"), - FindMessage(j, "a()", "c()", "")}; + save_json(config.output_directory(), diagram->name + ".json", j); + } - REQUIRE(std::is_sorted(messages.begin(), messages.end())); + { + auto src = generate_sequence_mermaid(diagram, *model); - save_json(config.output_directory(), diagram->name + ".json", j); - } + mermaid::SequenceDiagramAliasMatcher _A(src); + using mermaid::HasCall; - { - auto src = generate_sequence_mermaid(diagram, *model); + REQUIRE_THAT(src, HasCall(_A("tmain(int,char **)"), _A("a()"), "")); + REQUIRE_THAT(src, HasCall(_A("a()"), _A("initb()"), "")); + REQUIRE_THAT(src, HasCall(_A("a()"), _A("B"), "get()")); + REQUIRE_THAT(src, HasCall(_A("a()"), _A("c()"), "")); - mermaid::SequenceDiagramAliasMatcher _A(src); - using mermaid::HasCall; - - REQUIRE_THAT(src, HasCall(_A("tmain(int,char **)"), _A("a()"), "")); - REQUIRE_THAT(src, HasCall(_A("a()"), _A("initb()"), "")); - REQUIRE_THAT(src, HasCall(_A("a()"), _A("B"), "get()")); - REQUIRE_THAT(src, HasCall(_A("a()"), _A("c()"), "")); - - save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + save_mermaid(config.output_directory(), diagram->name + ".mmd", + src); + }*/ } \ No newline at end of file diff --git a/tests/t20038/test_case.h b/tests/t20038/test_case.h index dc0c8be9..d5e9336c 100644 --- a/tests/t20038/test_case.h +++ b/tests/t20038/test_case.h @@ -16,110 +16,144 @@ * limitations under the License. */ -TEST_CASE("t20038", "[test-case][sequence]") +TEST_CASE("t20038") { - auto [config, db] = load_config("t20038"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20038_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20038", "t20038_sequence"); - REQUIRE(diagram->name == "t20038_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain()", "B", "b()"}, // + {"B", "A", "a()"}, // + {"tmain()", "B", "b()"}, // + {"B", "A", "a()"}, // - auto model = generate_sequence_diagram(*db, diagram); + {"tmain()", "B", "bbb()"}, // + {"B", "A", "aaa()"}, // - REQUIRE(model->name() == "t20038_sequence"); + {"tmain()", "B", "bbbb()"}, // + {"B", "A", "aaaa()"}, // + {"A", "add(int,int)", ""}, // + {"add(int,int)", "add_impl(int,int)", ""}, // - { - auto src = generate_sequence_puml(diagram, *model); - AliasMatcher _A(src); + {"tmain()", "B", "wrap(int)"}, // - REQUIRE_THAT(src, StartsWith("@startuml")); - REQUIRE_THAT(src, EndsWith("@enduml\n")); + {"tmain()", "add_impl(double,double)", ""}, // - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b()")); + {"tmain()", "B", "bbbbb()"}, // + {"B", "A", "aaaa()"}, // + {"A", "add(int,int)", ""}, // + {"add(int,int)", "add_impl(int,int)", ""}, // - REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("B"), "bb()")); + {"tmain()", "B", "bbb()", InControlCondition{}}, // + {"B", "A", "aaa()"}, // + })); + }); + /* + { + auto src = generate_sequence_puml(diagram, *model); + AliasMatcher _A(src); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbb()")); + REQUIRE_THAT(src, StartsWith("@startuml")); + REQUIRE_THAT(src, EndsWith("@enduml\n")); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbbb()")); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b()")); - REQUIRE_THAT(src, - HasMessageComment(_A("tmain()"), - "This comment should be rendered only\\n" - "once")); + REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("B"), "bb()")); - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("add_impl(double,double)"), "")); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbb()")); - REQUIRE_THAT( - src, HasMessageComment(_A("tmain()"), "What is 2 \\+ 2\\?")); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbbb()")); - REQUIRE_THAT(src, - !HasMessageComment( - _A("tmain()"), "This is specific for some_other_diagram")); + REQUIRE_THAT(src, + HasMessageComment(_A("tmain()"), + "This comment should be rendered only\\n" + "once")); - REQUIRE_THAT( - src, HasMessageComment(_A("tmain()"), "Calling B::bbbbb\\(\\)")); + REQUIRE_THAT(src, + HasCall(_A("tmain()"), _A("add_impl(double,double)"), + "")); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbbbb()")); + REQUIRE_THAT( + src, HasMessageComment(_A("tmain()"), "What is 2 \\+ 2\\?")); - REQUIRE_THAT(src, - HasMessageComment(_A("tmain()"), "This is a conditional operator")); + REQUIRE_THAT(src, + !HasMessageComment( + _A("tmain()"), "This is specific for some_other_diagram")); - save_puml(config.output_directory(), diagram->name + ".puml", src); - } + REQUIRE_THAT( + src, HasMessageComment(_A("tmain()"), "Calling + B::bbbbb\\(\\)")); - { - auto j = generate_sequence_json(diagram, *model); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbbbb()")); - using namespace json; + REQUIRE_THAT(src, + HasMessageComment(_A("tmain()"), "This is a conditional + operator")); - save_json(config.output_directory(), diagram->name + ".json", j); - } + save_puml(config.output_directory(), diagram->name + ".puml", src); + } - { - auto src = generate_sequence_mermaid(diagram, *model); + { + auto j = generate_sequence_json(diagram, *model); - mermaid::SequenceDiagramAliasMatcher _A(src); - using mermaid::HasCall; - using mermaid::HasCallInControlCondition; - using mermaid::HasMessageComment; + using namespace json; - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b()")); + save_json(config.output_directory(), diagram->name + ".json", j); + } - REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("B"), "bb()")); + { + auto src = generate_sequence_mermaid(diagram, *model); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbb()")); + mermaid::SequenceDiagramAliasMatcher _A(src); + using mermaid::HasCall; + using mermaid::HasCallInControlCondition; + using mermaid::HasMessageComment; - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbbb()")); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "b()")); - REQUIRE_THAT(src, - HasMessageComment(_A("tmain()"), - "This comment should be rendered only
" - "once")); + REQUIRE_THAT(src, !HasCall(_A("tmain()"), _A("B"), "bb()")); - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("add_impl(double,double)"), "")); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbb()")); - REQUIRE_THAT( - src, HasMessageComment(_A("tmain()"), "What is 2 \\+ 2\\?")); + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbbb()")); - REQUIRE_THAT(src, - !HasMessageComment( - _A("tmain()"), "This is specific for some_other_diagram")); + REQUIRE_THAT(src, + HasMessageComment(_A("tmain()"), + "This comment should be rendered only
" + "once")); - REQUIRE_THAT( - src, HasMessageComment(_A("tmain()"), "Calling B::bbbbb\\(\\)")); + REQUIRE_THAT(src, + HasCall(_A("tmain()"), _A("add_impl(double,double)"), + "")); - REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbbbb()")); + REQUIRE_THAT( + src, HasMessageComment(_A("tmain()"), "What is 2 \\+ 2\\?")); - REQUIRE_THAT(src, - !HasMessageComment( - _A("tmain()"), "This is specific for some_other_diagram")); + REQUIRE_THAT(src, + !HasMessageComment( + _A("tmain()"), "This is specific for some_other_diagram")); - REQUIRE_THAT( - src, HasMessageComment(_A("tmain()"), "Calling B::bbbbb\\(\\)")); + REQUIRE_THAT( + src, HasMessageComment(_A("tmain()"), "Calling + B::bbbbb\\(\\)")); - save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + REQUIRE_THAT(src, HasCall(_A("tmain()"), _A("B"), "bbbbb()")); + + REQUIRE_THAT(src, + !HasMessageComment( + _A("tmain()"), "This is specific for some_other_diagram")); + + REQUIRE_THAT( + src, HasMessageComment(_A("tmain()"), "Calling + B::bbbbb\\(\\)")); + + save_mermaid(config.output_directory(), diagram->name + ".mmd", + src); + } + */ } \ No newline at end of file diff --git a/tests/t20039/test_case.h b/tests/t20039/test_case.h index 316d20e0..628bef51 100644 --- a/tests/t20039/test_case.h +++ b/tests/t20039/test_case.h @@ -16,18 +16,26 @@ * limitations under the License. */ -TEST_CASE("t20039", "[test-case][sequence]") +TEST_CASE("t20039") { - auto [config, db] = load_config("t20039"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20039_sequence"]; - - REQUIRE(diagram->name == "t20039_sequence"); - - auto model = generate_sequence_diagram(*db, diagram); - - REQUIRE(model->name() == "t20039_sequence"); + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20039", "t20039_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain()", "R", "run()"}, // + {"R", "A", "a(int)"}, // + {"R", "A", "a(int_vec_t)"}, // + {"R", "A", "a(string_vec_t)"}, // + {"R", "A", "a(int_map_t)"}, // + {"R", "A", "a(string_map_t)"} // + })); + }); +/* { auto src = generate_sequence_puml(diagram, *model); AliasMatcher _A(src); @@ -72,5 +80,5 @@ TEST_CASE("t20039", "[test-case][sequence]") src, HasCall(_A("R"), _A("A"), "a(string_map_t)")); save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + }*/ } \ No newline at end of file diff --git a/tests/t20040/test_case.h b/tests/t20040/test_case.h index 9ff98228..a9297bbd 100644 --- a/tests/t20040/test_case.h +++ b/tests/t20040/test_case.h @@ -16,74 +16,95 @@ * limitations under the License. */ -TEST_CASE("t20040", "[test-case][sequence]") +TEST_CASE("t20040") { - auto [config, db] = load_config("t20040"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20040_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20040", "t20040_sequence"); - REQUIRE(diagram->name == "t20040_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain()", + "print(int,double,std::string)", + ""}, // + {"print(int,double,std::string)", + "print(double,std::string)", ""}, // + {"print(double,std::string)", + "print(std::string)", ""}, // + {"print(std::string)", "print()", ""}, // - auto model = generate_sequence_diagram(*db, diagram); + {"tmain()", "doublePrint(std::string,int)", + ""}, // + {"doublePrint(std::string,int)", + "print(std::string,int)", ""}, // + {"print(std::string,int)", "print(int)", + ""}, // + {"print(int)", "print()", ""}, // + })); + }); + /* + { + auto src = generate_sequence_puml(diagram, *model); + AliasMatcher _A(src); - REQUIRE(model->name() == "t20040_sequence"); + REQUIRE_THAT(src, StartsWith("@startuml")); + REQUIRE_THAT(src, EndsWith("@enduml\n")); - { - auto src = generate_sequence_puml(diagram, *model); - AliasMatcher _A(src); + REQUIRE_THAT(src, + HasCall(_A("tmain()"), + _A("print(int,double,std::string)"), + "")); - REQUIRE_THAT(src, StartsWith("@startuml")); - REQUIRE_THAT(src, EndsWith("@enduml\n")); + REQUIRE_THAT(src, + HasCall(_A("print(int,double,std::string)"), + _A("print(double,std::string)"), "")); - REQUIRE_THAT(src, - HasCall(_A("tmain()"), - _A("print(int,double,std::string)"), - "")); + REQUIRE_THAT(src, + HasCall(_A("print(double,std::string)"), + _A("print(std::string)"), "")); - REQUIRE_THAT(src, - HasCall(_A("print(int,double,std::string)"), - _A("print(double,std::string)"), "")); + REQUIRE_THAT(src, + HasCall(_A("print(std::string)"), _A("print()"), + "")); - REQUIRE_THAT(src, - HasCall(_A("print(double,std::string)"), - _A("print(std::string)"), "")); + save_puml(config.output_directory(), diagram->name + ".puml", src); + } - REQUIRE_THAT(src, - HasCall(_A("print(std::string)"), _A("print()"), "")); + { + auto j = generate_sequence_json(diagram, *model); - save_puml(config.output_directory(), diagram->name + ".puml", src); - } + using namespace json; - { - auto j = generate_sequence_json(diagram, *model); + save_json(config.output_directory(), diagram->name + ".json", j); + } - using namespace json; + { + auto src = generate_sequence_mermaid(diagram, *model); - save_json(config.output_directory(), diagram->name + ".json", j); - } + mermaid::SequenceDiagramAliasMatcher _A(src); + using mermaid::HasCall; - { - auto src = generate_sequence_mermaid(diagram, *model); + REQUIRE_THAT(src, + HasCall(_A("tmain()"), + _A("print(int,double,std::string)"), + "")); - mermaid::SequenceDiagramAliasMatcher _A(src); - using mermaid::HasCall; + REQUIRE_THAT(src, + HasCall(_A("print(int,double,std::string)"), + _A("print(double,std::string)"), "")); - REQUIRE_THAT(src, - HasCall(_A("tmain()"), - _A("print(int,double,std::string)"), - "")); + REQUIRE_THAT(src, + HasCall(_A("print(double,std::string)"), + _A("print(std::string)"), "")); - REQUIRE_THAT(src, - HasCall(_A("print(int,double,std::string)"), - _A("print(double,std::string)"), "")); + REQUIRE_THAT(src, + HasCall(_A("print(std::string)"), _A("print()"), + "")); - REQUIRE_THAT(src, - HasCall(_A("print(double,std::string)"), - _A("print(std::string)"), "")); - - REQUIRE_THAT(src, - HasCall(_A("print(std::string)"), _A("print()"), "")); - - save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + save_mermaid(config.output_directory(), diagram->name + ".mmd", + src); + }*/ } \ No newline at end of file diff --git a/tests/t20041/test_case.h b/tests/t20041/test_case.h index c3198068..7e8bb3ed 100644 --- a/tests/t20041/test_case.h +++ b/tests/t20041/test_case.h @@ -16,74 +16,84 @@ * limitations under the License. */ -TEST_CASE("t20041", "[test-case][sequence]") +TEST_CASE("t20041") { - auto [config, db] = load_config("t20041"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20041_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20041", "t20041_sequence"); - REQUIRE(diagram->name == "t20041_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain()", "A", + "print(int,double,std::string)"}, // + {"A", "A", + "print(double,std::string)"}, // + {"A", "A", + "print(std::string)"}, // + {"A", "A", "print()"}, // + })); + }); + /* + { + auto src = generate_sequence_puml(diagram, *model); + AliasMatcher _A(src); - auto model = generate_sequence_diagram(*db, diagram); + REQUIRE_THAT(src, StartsWith("@startuml")); + REQUIRE_THAT(src, EndsWith("@enduml\n")); - REQUIRE(model->name() == "t20041_sequence"); + REQUIRE_THAT(src, + HasCall(_A("tmain()"), _A("A"), + "print(int,double,std::string)")); + REQUIRE_THAT(src, + HasCall(_A("A"), + _A("A"), "print(double,std::string)")); + REQUIRE_THAT(src, + HasCall(_A("A"), _A("A"), + "print(std::string)")); + REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), + "print()")); - { - auto src = generate_sequence_puml(diagram, *model); - AliasMatcher _A(src); + save_puml(config.output_directory(), diagram->name + ".puml", src); + } - REQUIRE_THAT(src, StartsWith("@startuml")); - REQUIRE_THAT(src, EndsWith("@enduml\n")); + { + auto j = generate_sequence_json(diagram, *model); - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("A"), - "print(int,double,std::string)")); - REQUIRE_THAT(src, - HasCall(_A("A"), - _A("A"), "print(double,std::string)")); - REQUIRE_THAT(src, - HasCall(_A("A"), _A("A"), - "print(std::string)")); - REQUIRE_THAT(src, HasCall(_A("A"), _A("A"), "print()")); + using namespace json; - save_puml(config.output_directory(), diagram->name + ".puml", src); - } + std::vector messages = { + FindMessage(j, "tmain()", "A", + "print(int,double,std::string)"), + FindMessage(j, "A", + "A", "print(double,std::string)"), FindMessage(j, + "A", "A", "print(std::string)"), + FindMessage(j, "A", "A", "print()")}; - { - auto j = generate_sequence_json(diagram, *model); + REQUIRE(std::is_sorted(messages.begin(), messages.end())); - using namespace json; + save_json(config.output_directory(), diagram->name + ".json", j); + } - std::vector messages = { - FindMessage(j, "tmain()", "A", - "print(int,double,std::string)"), - FindMessage(j, "A", "A", - "print(double,std::string)"), - FindMessage(j, "A", "A", - "print(std::string)"), - FindMessage(j, "A", "A", "print()")}; + { + auto src = generate_sequence_mermaid(diagram, *model); - REQUIRE(std::is_sorted(messages.begin(), messages.end())); + mermaid::SequenceDiagramAliasMatcher _A(src); + using mermaid::HasCall; - save_json(config.output_directory(), diagram->name + ".json", j); - } + REQUIRE_THAT(src, + HasCall(_A("tmain()"), _A("A"), + "print(int,double,std::string)")); + REQUIRE_THAT(src, + HasCall(_A("A"), + _A("A"), "print(double,std::string)")); + REQUIRE_THAT(src, + HasCall(_A("A"), _A("A"), + "print(std::string)")); - { - auto src = generate_sequence_mermaid(diagram, *model); - - mermaid::SequenceDiagramAliasMatcher _A(src); - using mermaid::HasCall; - - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("A"), - "print(int,double,std::string)")); - REQUIRE_THAT(src, - HasCall(_A("A"), - _A("A"), "print(double,std::string)")); - REQUIRE_THAT(src, - HasCall(_A("A"), _A("A"), - "print(std::string)")); - - save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + save_mermaid(config.output_directory(), diagram->name + ".mmd", + src); + }*/ } \ No newline at end of file diff --git a/tests/t20042/test_case.h b/tests/t20042/test_case.h index 3e2276d8..31db9cc9 100644 --- a/tests/t20042/test_case.h +++ b/tests/t20042/test_case.h @@ -16,60 +16,64 @@ * limitations under the License. */ -TEST_CASE("t20042", "[test-case][sequence]") +TEST_CASE("t20042") { - auto [config, db] = load_config("t20042"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20042_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20042", "t20042_sequence"); - REQUIRE(diagram->name == "t20042_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain()", "AHandler", "operator()(A &) const"}, // + {"AHandler", "AHandler", "handle(A &) const"}, // - auto model = generate_sequence_diagram(*db, diagram); + {"tmain()", "BHandler", "operator()(B &) const"}, // + {"BHandler", "BHandler", "handle(B &) const"}, // + })); + }); + /* + { + auto src = generate_sequence_puml(diagram, *model); + AliasMatcher _A(src); - REQUIRE(model->name() == "t20042_sequence"); + REQUIRE_THAT(src, StartsWith("@startuml")); + REQUIRE_THAT(src, EndsWith("@enduml\n")); - { - auto src = generate_sequence_puml(diagram, *model); - AliasMatcher _A(src); + REQUIRE_THAT(src, + HasCall(_A("tmain()"), _A("AHandler"), "operator()(A &) + const")); REQUIRE_THAT( src, HasCall(_A("AHandler"), _A("AHandler"), + "handle(A &) const")); REQUIRE_THAT(src, HasCall(_A("tmain()"), + _A("BHandler"), "operator()(B &) const")); REQUIRE_THAT( src, + HasCall(_A("BHandler"), _A("BHandler"), "handle(B &) const")); - REQUIRE_THAT(src, StartsWith("@startuml")); - REQUIRE_THAT(src, EndsWith("@enduml\n")); + save_puml(config.output_directory(), diagram->name + ".puml", src); + } - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("AHandler"), "operator()(A &) const")); - REQUIRE_THAT( - src, HasCall(_A("AHandler"), _A("AHandler"), "handle(A &) const")); - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("BHandler"), "operator()(B &) const")); - REQUIRE_THAT( - src, HasCall(_A("BHandler"), _A("BHandler"), "handle(B &) const")); + { + auto j = generate_sequence_json(diagram, *model); - save_puml(config.output_directory(), diagram->name + ".puml", src); - } + using namespace json; - { - auto j = generate_sequence_json(diagram, *model); + save_json(config.output_directory(), diagram->name + ".json", j); + } - using namespace json; + { + auto src = generate_sequence_mermaid(diagram, *model); - save_json(config.output_directory(), diagram->name + ".json", j); - } + mermaid::SequenceDiagramAliasMatcher _A(src); + using mermaid::HasCall; - { - auto src = generate_sequence_mermaid(diagram, *model); + REQUIRE_THAT(src, + HasCall(_A("tmain()"), _A("AHandler"), "operator()(A &) + const")); REQUIRE_THAT( src, HasCall(_A("AHandler"), _A("AHandler"), + "handle(A &) const")); REQUIRE_THAT(src, HasCall(_A("tmain()"), + _A("BHandler"), "operator()(B &) const")); REQUIRE_THAT( src, + HasCall(_A("BHandler"), _A("BHandler"), "handle(B &) const")); - mermaid::SequenceDiagramAliasMatcher _A(src); - using mermaid::HasCall; - - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("AHandler"), "operator()(A &) const")); - REQUIRE_THAT( - src, HasCall(_A("AHandler"), _A("AHandler"), "handle(A &) const")); - REQUIRE_THAT(src, - HasCall(_A("tmain()"), _A("BHandler"), "operator()(B &) const")); - REQUIRE_THAT( - src, HasCall(_A("BHandler"), _A("BHandler"), "handle(B &) const")); - - save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + save_mermaid(config.output_directory(), diagram->name + ".mmd", + src); + }*/ } \ No newline at end of file diff --git a/tests/t20043/test_case.h b/tests/t20043/test_case.h index 84c0a4e9..6a17feb1 100644 --- a/tests/t20043/test_case.h +++ b/tests/t20043/test_case.h @@ -16,18 +16,28 @@ * limitations under the License. */ -TEST_CASE("t20043", "[test-case][sequence]") +TEST_CASE("t20043") { - auto [config, db] = load_config("t20043"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20043_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20043", "t20043_sequence"); - REQUIRE(diagram->name == "t20043_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain()", "D", "d()"}, // + {"D", "C", "c()"}, // + })); - auto model = generate_sequence_diagram(*db, diagram); - - REQUIRE(model->name() == "t20043_sequence"); + REQUIRE(!HasMessage(src, {"tmain()", "F", "f()"})); + REQUIRE(!HasMessage(src, {"D", {"detail", "E"}, "e()"})); + REQUIRE(!HasMessage(src, {"C", "B", "b()"})); + REQUIRE(!HasMessage(src, {"B", "A", "a()"})); + }); +/* { auto src = generate_sequence_puml(diagram, *model); AliasMatcher _A(src); @@ -69,5 +79,5 @@ TEST_CASE("t20043", "[test-case][sequence]") REQUIRE_THAT(src, !HasCall(_A("B"), _A("A"), "a()")); save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + }*/ } \ No newline at end of file diff --git a/tests/t20044/test_case.h b/tests/t20044/test_case.h index 3ff700b3..8ff25df6 100644 --- a/tests/t20044/test_case.h +++ b/tests/t20044/test_case.h @@ -16,18 +16,47 @@ * limitations under the License. */ -TEST_CASE("t20044", "[test-case][sequence]") +TEST_CASE("t20044") { - auto [config, db] = load_config("t20044"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20044_sequence"]; + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20044", "t20044_sequence"); - REQUIRE(diagram->name == "t20044_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain()", "R", "R((lambda at t20044.cc:74:9) &&)"}, // + {"R", "tmain()::(lambda t20044.cc:74:9)", + "operator()() const"}, // + {"tmain()::(lambda t20044.cc:74:9)", "A", "a() const"}, // - auto model = generate_sequence_diagram(*db, diagram); + {"tmain()", "tmain()::(lambda t20044.cc:84:18)", + "operator()() const"}, // + {"tmain()::(lambda t20044.cc:84:18)", "A", "a5()"}, // - REQUIRE(model->name() == "t20044_sequence"); + {"tmain()", "A", "a1() const"}, // + {"A", "detail::expected", "expected(int)"}, // + {"tmain()", "detail::expected", + "and_then((lambda at t20044.cc:90:19) &&)"}, // + {"detail::expected", + "tmain()::(lambda t20044.cc:90:19)", + "operator()(auto &&) const"}, // + {"tmain()::(lambda t20044.cc:90:19)", "A", "a2(int) const"}, // + {"A", "detail::expected", "expected(int)"}, // + + {"tmain()", "detail::expected", + "and_then(result_t (&)(int))"}, // // + {"tmain()", "detail::expected", + "and_then(std::function &)"}, // // + {"tmain()", "detail::expected", + "value() const"}, // // + + })); + }); +/* { auto src = generate_sequence_puml(diagram, *model); AliasMatcher _A(src); @@ -88,5 +117,5 @@ TEST_CASE("t20044", "[test-case][sequence]") using mermaid::IsClass; save_mermaid(config.output_directory(), diagram->name + ".mmd", src); - } + }*/ } \ No newline at end of file diff --git a/tests/t20045/test_case.h b/tests/t20045/test_case.h index 5d8d7775..fe49289e 100644 --- a/tests/t20045/test_case.h +++ b/tests/t20045/test_case.h @@ -16,18 +16,25 @@ * limitations under the License. */ -TEST_CASE("t20045", "[test-case][sequence]") +TEST_CASE("t20045") { - auto [config, db] = load_config("t20045"); + using namespace clanguml::test; - auto diagram = config.diagrams["t20045_sequence"]; - - REQUIRE(diagram->name == "t20045_sequence"); - - auto model = generate_sequence_diagram(*db, diagram); - - REQUIRE(model->name() == "t20045_sequence"); + auto [config, db, diagram, model] = + CHECK_SEQUENCE_MODEL("t20045", "t20045_sequence"); + CHECK_SEQUENCE_DIAGRAM(config, diagram, *model, [](const auto &src) { + REQUIRE(MessageOrder(src, + { + // + {"tmain()", "a2(int)", ""}, // + {"tmain()", + "a1<(lambda at t20045.cc:35:18)>((lambda at " + "t20045.cc:35:18) &&)", + ""}, // + })); + }); +/* { auto src = generate_sequence_puml(diagram, *model); AliasMatcher _A(src); @@ -80,4 +87,5 @@ TEST_CASE("t20045", "[test-case][sequence]") save_mermaid(config.output_directory(), diagram->name + ".mmd", src); } + */ } \ No newline at end of file diff --git a/tests/test_cases.cc b/tests/test_cases.cc index e235089b..fef05561 100644 --- a/tests/test_cases.cc +++ b/tests/test_cases.cc @@ -387,8 +387,7 @@ void try_run_test_case(const diagram_source_storage &diagrams, TC &&tc) std::cout << "-----------------------------------------------------" "--------------------------\n"; std::cout << "Test case failed for diagram type " - << T::diagram_type_name << ": " - << "\n\n"; + << T::diagram_type_name << ": " << "\n\n"; std::cout << diagrams.get().to_string() << "\n"; throw e; @@ -591,7 +590,6 @@ void CHECK_INCLUDE_DIAGRAM(const clanguml::config::config &config, save_mermaid(config.output_directory(), diagram->name + ".mmd", diagram_sources.mermaid.src); } - } // namespace clanguml::test /* @@ -1174,7 +1172,7 @@ template <> bool IsClass(json_t d, std::string name) #include "t00074/test_case.h" #include "t00075/test_case.h" #endif -/* + /// /// Sequence diagram tests /// @@ -1188,6 +1186,7 @@ template <> bool IsClass(json_t d, std::string name) #include "t20005/test_case.h" #endif #include "t20006/test_case.h" + #include "t20007/test_case.h" #include "t20008/test_case.h" #include "t20009/test_case.h" @@ -1222,11 +1221,13 @@ template <> bool IsClass(json_t d, std::string name) #include "t20038/test_case.h" #include "t20039/test_case.h" #include "t20040/test_case.h" + #include "t20041/test_case.h" #include "t20042/test_case.h" #include "t20043/test_case.h" #include "t20044/test_case.h" #include "t20045/test_case.h" +/* #include "t20046/test_case.h" #include "t20047/test_case.h" #include "t20048/test_case.h" diff --git a/tests/test_cases.h b/tests/test_cases.h index 06f0d65f..b85defb3 100644 --- a/tests/test_cases.h +++ b/tests/test_cases.h @@ -84,6 +84,12 @@ struct Default { }; struct Deleted { }; +struct Entrypoint { }; + +struct Exitpoint { }; + +struct InControlCondition { }; +struct Response { }; struct NamespacePackage { }; struct ModulePackage { }; struct DirectoryPackage { }; @@ -123,6 +129,8 @@ template struct diagram_source_t { bool search(const std::string &pattern) const; + int64_t find(const std::string &pattern, int64_t offset = 0) const; + std::string to_string() const; T src; @@ -189,7 +197,7 @@ struct mermaid_t : public diagram_source_t { inline static const std::string diagram_type_name{"MermaidJS"}; - std::string get_alias(std::string name) const override + std::string get_alias_impl(std::string name) const { std::vector patterns; @@ -224,6 +232,44 @@ struct mermaid_t : public diagram_source_t { return fmt::format("__INVALID__ALIAS__({})", name); } + + std::string get_alias_sequence_diagram_impl(std::string name) const + { + std::vector patterns; + + const std::string alias_regex("([A-Z]_[0-9]+)"); + + util::replace_all(name, "(", "\\("); + util::replace_all(name, ")", "\\)"); + util::replace_all(name, " ", "\\s"); + util::replace_all(name, "*", "\\*"); + util::replace_all(name, "[", "\\["); + util::replace_all(name, "]", "\\]"); + + patterns.push_back( + std::regex{"participant\\s" + alias_regex + "\\sas\\s" + name+"\\n"}); + + std::smatch base_match; + + for (const auto &pattern : patterns) { + if (std::regex_search(src, base_match, pattern) && + base_match.size() == 2) { + std::ssub_match base_sub_match = base_match[1]; + std::string alias = base_sub_match.str(); + return trim(alias); + } + } + + return fmt::format("__INVALID__ALIAS__({})", name); + } + + std::string get_alias(std::string name) const override + { + if (diagram_type == common::model::diagram_t::kSequence) + return get_alias_sequence_diagram_impl(name); + + return get_alias_impl(name); + } }; struct json_t : public diagram_source_t { @@ -338,12 +384,26 @@ template <> bool diagram_source_t::contains(std::string name) const } template <> -bool diagram_source_t::search(const std::string &pattern) const +int64_t diagram_source_t::find( + const std::string &pattern, int64_t offset) const { std::regex pattern_regex{pattern}; std::smatch base_match; - return std::regex_search(src, base_match, pattern_regex); + auto offset_it = src.begin(); + std::advance(offset_it, offset); + bool found = + std::regex_search(offset_it, src.end(), base_match, pattern_regex); + if (!found) + return -1; + + return base_match.position(0); +} + +template <> +bool diagram_source_t::search(const std::string &pattern) const +{ + return find(pattern) > -1; } template <> @@ -399,6 +459,46 @@ struct QualifiedName { std::string name; }; +struct Message { + template + Message(QualifiedName f, QualifiedName t, std::string m, Attrs &&...attrs) + : from{std::move(f)} + , to{std::move(t)} + , message{std::move(m)} + , is_static{has_type()} + , is_incontrolcondition{has_type()} + , is_response{has_type()} + { + } + + template + Message(Entrypoint &&e, QualifiedName t, std::string m, Attrs &&...attrs) + : Message(QualifiedName{""}, std::move(t), {}, + std::forward(attrs)...) + { + is_entrypoint = true; + } + + template + Message(Exitpoint &&e, QualifiedName t, Attrs &&...attrs) + : Message(QualifiedName{""}, std::move(t), {}, + std::forward(attrs)...) + { + is_exitpoint = true; + } + + QualifiedName from; + QualifiedName to; + std::string message; + std::optional return_type; + + bool is_static{false}; + bool is_entrypoint{false}; + bool is_exitpoint{false}; + bool is_incontrolcondition{false}; + bool is_response{false}; +}; + /// /// The following functions declarations define various checks on generated /// diagrams. @@ -574,6 +674,80 @@ bool IsModulePackage(const DiagramType &d, Args... args); template bool IsDeprecated(const DiagramType &d, std::string const &str); +template +int64_t FindMessage(const DiagramType &d, const Message &msg, + int64_t offset = 0, bool fail = true); + +template +bool HasMessage(const DiagramType &d, const Message &msg) +{ + return FindMessage(d, msg, 0, false) >= 0; +} + +template +bool MessageOrder(const DiagramType &d, std::vector messages) +{ + std::vector order; + int64_t offset{0}; + order.reserve(messages.size()); + std::transform(messages.begin(), messages.end(), std::back_inserter(order), + [&d, &offset](const auto &m) { + offset = FindMessage(d, m, offset); + return offset; + }); + bool are_messages_in_order = std::is_sorted(order.begin(), order.end()); + + if (!are_messages_in_order) { + FAIL(fmt::format( + "Messages are not in order: \n[{}]", fmt::join(order, ",\n"))); + return false; + } + + return true; +} + +template +bool MessageChainsOrder( + const DiagramType &d, std::vector> message_chains) +{ + std::vector flattenned; + for (const auto &mc : message_chains) { + for (const auto &m : mc) + flattenned.emplace_back(m); + } + + return MessageOrder(d, std::move(flattenned)); +} + +template +bool IsParticipant( + const DiagramType &d, const std::string &name, const std::string &type); + +template +bool IsFunctionParticipant(const DiagramType &d, const std::string &name) +{ + return IsParticipant(d, name, "function"); +} + +template +bool IsFunctionTemplateParticipant( + const DiagramType &d, const std::string &name) +{ + return IsParticipant(d, name, "function_template"); +} + +template +bool IsClassParticipant(const DiagramType &d, const std::string &name) +{ + return IsParticipant(d, name, "class"); +} + +template +bool IsFileParticipant(const DiagramType &d, const std::string &name) +{ + return IsParticipant(d, name, "file"); +} + /// /// @} /// @@ -912,14 +1086,6 @@ bool HasNote(const plantuml_t &d, std::string const &cls, return d.contains(fmt::format("note {} of {}", position, d.get_alias(cls))); } -template <> -bool HasMessageComment(const plantuml_t &d, std::string const &participant, - std::string const ¬e) -{ - return d.contains(std::string("note over ") + d.get_alias(participant) + - "\\n" + note + "\\n" + "end note"); -} - template <> bool HasMemberNote(const plantuml_t &d, std::string const &cls, std::string const &member, std::string const &position, @@ -1019,6 +1185,81 @@ template <> bool IsDeprecated(const plantuml_t &d, const std::string &name) return d.contains(d.get_alias(name) + " <> "); } +template <> +int64_t FindMessage( + const plantuml_t &d, const Message &msg, int64_t offset, bool fail) +{ + auto msg_str = msg.message; + util::replace_all(msg_str, "(", "\\("); + util::replace_all(msg_str, ")", "\\)"); + util::replace_all(msg_str, "*", "\\*"); + util::replace_all(msg_str, "[", "\\["); + util::replace_all(msg_str, "]", "\\]"); + util::replace_all(msg_str, "+", "\\+"); + + std::string style; + if (msg.is_static) + style = "__"; + + std::string call_pattern{"__INVALID__"}; + + if (msg.is_entrypoint) { + call_pattern = + fmt::format("\\[-> {} : {}", d.get_alias(msg.to), msg_str); + } + else if (msg.is_exitpoint) { + call_pattern = fmt::format("\\[<-- {}", d.get_alias(msg.to)); + } + else if (msg.is_incontrolcondition) { + call_pattern = fmt::format( + "{} {} {} " + "(\\[\\[.*\\]\\] )?: \\*\\*\\[\\*\\*{}{}{}\\*\\*\\]\\*\\*", + d.get_alias(msg.from), "->", d.get_alias(msg.to), style, msg_str, + style); + } + else if (msg.is_response) { + call_pattern = fmt::format("{} {} {} : //{}//", d.get_alias(msg.from), + "-->", d.get_alias(msg.to), msg_str); + } + else { + call_pattern = fmt::format("{} {} {} " + "(\\[\\[.*\\]\\] )?: {}{}{}", + d.get_alias(msg.from), "->", d.get_alias(msg.to), style, msg_str, + style); + } + + auto match_offset = d.find(call_pattern, offset); + + if (match_offset < 0) { + if (fail) + FAIL(fmt::format("Missing message: {} -> {} {} ({})", + msg.from.str(), msg.to.str(), msg.message, call_pattern)); + return -1; + } + + return match_offset + offset; +} + +template <> +bool HasMessageComment(const plantuml_t &d, std::string const &participant, + std::string const ¬e) +{ + std::string note_escaped{note}; + util::replace_all(note_escaped, "(", "\\("); + util::replace_all(note_escaped, ")", "\\)"); + + return d.search(fmt::format("note over {}\\n{}\\nend note", + d.get_alias(participant), note_escaped)); +} + +template <> +bool IsParticipant( + const plantuml_t &d, const std::string &name, const std::string &type) +{ + return d.contains( + fmt::format("participant \"{}\" as ", name, d.get_alias(name))); +} + // // MermaidJS test helpers // @@ -1052,7 +1293,6 @@ template <> bool IsClassTemplate(const mermaid_t &d, QualifiedName cls) template <> bool IsAbstractClassTemplate(const mermaid_t &d, QualifiedName cls) { - // return d.contains(fmt::format("class {}", d.get_alias(cls))); return d.search( std::string("class ") + d.get_alias(cls) + " \\{\\n\\s+<>"); } @@ -1367,8 +1607,6 @@ bool IsConceptRequirement( { util::replace_all(requirement, "<", "<"); util::replace_all(requirement, ">", ">"); - // util::replace_all(requirement, "(", "("); - // util::replace_all(requirement, ")", ")"); util::replace_all(requirement, "##", "::"); util::replace_all(requirement, "{", "{"); util::replace_all(requirement, "}", "}"); @@ -1382,8 +1620,6 @@ bool IsConceptParameterList( { util::replace_all(params, "<", "<"); util::replace_all(params, ">", ">"); - // util::replace_all(requirement, "(", "("); - // util::replace_all(requirement, ")", ")"); util::replace_all(params, "##", "::"); util::replace_all(params, "{", "{"); util::replace_all(params, "}", "}"); @@ -1414,14 +1650,6 @@ bool HasNote(const mermaid_t &d, std::string const &cls, return d.contains(fmt::format("note for {}", d.get_alias(cls))); } -template <> -bool HasMessageComment( - const mermaid_t &d, std::string const &participant, std::string const ¬e) -{ - return d.contains( - std::string("note over ") + d.get_alias(participant) + ": " + note); -} - template <> bool HasMemberNote(const mermaid_t &d, std::string const &cls, std::string const &member, std::string const &position, @@ -1509,6 +1737,71 @@ template <> bool IsDeprecated(const mermaid_t &d, const std::string &name) return d.contains(d.get_alias(name)); } +template <> +int64_t FindMessage( + const mermaid_t &d, const Message &msg, int64_t offset, bool fail) +{ + auto msg_str = msg.message; + + util::replace_all(msg_str, "(", "\\("); + util::replace_all(msg_str, ")", "\\)"); + util::replace_all(msg_str, "*", "\\*"); + util::replace_all(msg_str, "[", "\\["); + util::replace_all(msg_str, "]", "\\]"); + util::replace_all(msg_str, "+", "\\+"); + + std::string call_pattern{"__INVALID__"}; + + if (msg.is_entrypoint) { + call_pattern = + fmt::format("\\* ->> {} : {}", d.get_alias(msg.to), msg_str); + } + else if (msg.is_exitpoint) { + call_pattern = fmt::format("{} -->> \\*", d.get_alias(msg.to), msg_str); + } + else if (msg.is_incontrolcondition) { + call_pattern = fmt::format("{} {} {} : \\[{}\\]", d.get_alias(msg.from), + "->>", d.get_alias(msg.to), msg_str); + } + else if (msg.is_response) { + call_pattern = fmt::format("{} {} {} : {}", d.get_alias(msg.from), + "-->>", d.get_alias(msg.to), msg_str); + } + else { + call_pattern = fmt::format("{} {} {} : {}", d.get_alias(msg.from), + "->>", d.get_alias(msg.to), msg_str); + } + + auto match_offset = d.find(call_pattern, offset); + + if (match_offset < 0) { + if (fail) + FAIL(fmt::format("Missing message: {} -> {} {} ({})", + msg.from.str(), msg.to.str(), msg.message, call_pattern)); + return -1; + } + + return match_offset + offset; +} + +template <> +bool HasMessageComment( + const mermaid_t &d, std::string const &participant, std::string const ¬e) +{ + std::string note_escaped{note}; + util::replace_all(note_escaped, "\\n", "
"); + + return d.contains(std::string("note over ") + d.get_alias(participant) + + ": " + note_escaped); +} + +template <> +bool IsParticipant( + const mermaid_t &d, const std::string &name, const std::string &type) +{ + return d.contains(fmt::format("participant {}", d.get_alias(name))); +} + // // JSON test helpers // @@ -1910,13 +2203,6 @@ bool HasPackageNote(const json_t &d, std::string const &cls, return true; } -template <> -bool HasMessageComment( - const json_t &d, std::string const &alias, std::string const ¬e) -{ - return true; -} - template <> bool HasMemberNote(const json_t &d, std::string const &cls, std::string const &member, std::string const &position, @@ -2044,6 +2330,207 @@ template <> bool IsDeprecated(const json_t &d, const std::string &name) auto e = get_element(j, expand_name(j, name)); return e && e->at("is_deprecated") == true; } + +namespace json_helpers { +int find_message_nested(const nlohmann::json &j, const std::string &from, + const std::string &to, const std::string &msg, + std::optional return_type, const nlohmann::json &from_p, + const nlohmann::json &to_p, int &count, const int64_t offset, + std::optional chain_index = {}) +{ + if (!j.contains("messages") && !j.contains("message_chains")) + return -1; + + const auto &messages = !chain_index.has_value() + ? j["messages"] + : j["message_chains"][chain_index.value()]["messages"]; + + int res{-1}; + + for (const auto &m : messages) { + if (m.contains("branches")) { + for (const auto &b : m["branches"]) { + auto nested_res = find_message_nested( + b, from, to, msg, return_type, from_p, to_p, count, offset); + + if (nested_res >= offset) + return nested_res; + } + } + else if (m.contains("messages")) { + auto nested_res = find_message_nested( + m, from, to, msg, return_type, from_p, to_p, count, offset); + + if (nested_res >= offset) + return nested_res; + } + else { + if (count >= offset && + (m["from"]["participant_id"] == from_p["id"]) && + (m["to"]["participant_id"] == to_p["id"]) && + (m["name"] == msg) && + (!return_type || m["return_type"] == *return_type)) + return count; + + count++; + } + } + + return res; +} + +int find_message_impl(const nlohmann::json &j, const std::string &from, + const std::string &to, const std::string &msg, + std::optional return_type, int64_t offset, + std::optional chain_index = {}) +{ + + auto from_p = get_participant(j, from); + auto to_p = get_participant(j, to); + + // TODO: support diagrams with multiple sequences... + int count{0}; + + for (const auto &seq : j["sequences"]) { + int64_t res{-1}; + + res = find_message_nested(seq, from, to, msg, return_type, *from_p, + *to_p, count, offset, chain_index); + + if (res >= 0) + return res; + } + + throw std::runtime_error(fmt::format( + "No such message {} {} {} after offset {}", from, to, msg, offset)); +} + +int64_t find_message(const nlohmann::json &j, const File &from, const File &to, + const std::string &msg, int64_t offset) +{ + return find_message_impl(j, from.file, to.file, msg, {}, offset); +} + +int64_t find_message(const nlohmann::json &j, const std::string &from, + const std::string &to, const std::string &msg, + std::optional return_type = {}, int64_t offset = 0) +{ + return find_message_impl( + j, expand_name(j, from), expand_name(j, to), msg, return_type, offset); +} + +int64_t find_message_in_chain(const nlohmann::json &j, const std::string &from, + const std::string &to, const std::string &msg, + std::optional return_type = {}, int64_t offset = 0, + uint32_t chain_index = 0) +{ + return find_message_impl(j, expand_name(j, from), expand_name(j, to), msg, + return_type, offset, chain_index); +} + +} // namespace detail + +template <> +int64_t FindMessage( + const json_t &d, const Message &msg, int64_t offset, bool fail) +{ + if (msg.is_response) { + // TODO: Currently response are not generated as separate messages in + // JSON format + return offset; + } + + if (msg.is_entrypoint || msg.is_exitpoint) + return offset; + + try { + return json_helpers::find_message(d.src, msg.from.str(), msg.to.str(), + msg.message, msg.return_type, offset); + } + catch (std::exception &e) { + if (!fail) + return -1; + + std::cout << "FindMessage failed with error " << e.what() << "\n"; + + throw e; + } +} + +int64_t find_message_in_chain(const json_t &d, const Message &msg, + int64_t offset, bool fail, uint32_t chain_index) +{ + if (msg.is_response) { + // TODO: Currently response are not generated as separate messages in + // JSON format + return offset; + } + + if (msg.is_entrypoint || msg.is_exitpoint) + return offset; + + try { + return json_helpers::find_message_in_chain(d.src, msg.from.str(), + msg.to.str(), msg.message, msg.return_type, offset, chain_index); + } + catch (std::exception &e) { + if (!fail) + return -1; + + std::cout << "find_message_in_chain failed with " << e.what() << "\n"; + + throw e; + } +} + +template <> +bool MessageChainsOrder( + const json_t &d, std::vector> message_chains) +{ + uint32_t chain_index{0}; + for (const auto &messages : message_chains) { + int64_t offset{0}; + + std::vector order; + order.reserve(messages.size()); + std::transform(messages.begin(), messages.end(), + std::back_inserter(order), + [&d, &offset, chain_index](const auto &m) { + offset = find_message_in_chain(d, m, offset, true, chain_index); + return offset; + }); + + bool are_messages_in_order = std::is_sorted(order.begin(), order.end()); + + chain_index++; + + if (!are_messages_in_order) { + FAIL(fmt::format( + "Messages are not in order: \n[{}]", fmt::join(order, ",\n"))); + return false; + } + } + + return true; +} + +template <> +bool HasMessageComment( + const json_t &d, std::string const &alias, std::string const ¬e) +{ + return true; +} + +template <> +bool IsParticipant( + const json_t &d, const std::string &name, const std::string &type) +{ + const auto &j = d.src; + + auto p = get_participant(j, expand_name(j, name)); + + return p && (p->at("type") == type); +} } /*