Fixed formatting

src/sequence_diagram/generators/plantuml/sequence_diagram_generator.cc

@@ -113,7 +113,7 @@ void generator::generate_participants(std::ostream &ostr) const
         ostr << "participant \""
              << m_config.using_namespace().relative(
                     participant.full_name(false))
-             << "\" as " << participant.alias()<< '\n';
+             << "\" as " << participant.alias() << '\n';
     }
 }
 

src/sequence_diagram/model/diagram.cc

@@ -29,10 +29,10 @@ common::model::diagram_t diagram::type() const
 }
 
 common::optional_ref<common::model::diagram_element> diagram::get(
-    const std::string & full_name) const
+    const std::string &full_name) const
 {
-    for(const auto& [id, participant] : participants) {
+    for (const auto &[id, participant] : participants) {
-        if(participant->full_name(false) == full_name)
+        if (participant->full_name(false) == full_name)
             return {*participant};
     }
 
@@ -42,7 +42,7 @@ common::optional_ref<common::model::diagram_element> diagram::get(
 common::optional_ref<common::model::diagram_element> diagram::get(
     const common::model::diagram_element::id_t id) const
 {
-    if(participants.find(id) != participants.end())
+    if (participants.find(id) != participants.end())
         return {*participants.at(id)};
 
     return {};

src/sequence_diagram/visitor/translation_unit_visitor.cc

@@ -433,9 +433,10 @@ bool translation_unit_visitor::VisitCallExpr(clang::CallExpr *expr)
                 set_ast_local_id(callee_function->getID(), f_ptr->id());
                 diagram().add_participant(std::move(f_ptr));
 
-                // This is not optimal way to check whether the callee declaration
+                // This is not optimal way to check whether the callee
-                // is implicit or explicit (we don't want implicit declarations
+                // declaration is implicit or explicit (we don't want implicit
-                // as separate participants), but is there a better way?
+                // declarations as separate participants), but is there a better
+                // way?
                 is_implicit = true;
             }
 

tests/t20004/t20004.cc

@@ -9,10 +9,8 @@ template <typename T> T m2(T p) { return m3<T>(p); }
 
 template <typename T> T m1(T p) { return m2<T>(p); }
 
-template<> [[maybe_unused]] int m4<int>(int p) { return p+2; }
+template <> [[maybe_unused]] int m4<int>(int p) { return p + 2; }
 
-int main() {
+int main() { return m1<int>(0); }
-    return m1<int>(0);
-}
 }
 }

tests/test_cases.h

@@ -122,18 +122,16 @@ struct HasCallWithResultMatcher : ContainsMatcher {
 ContainsMatcher HasCall(std::string const &from, std::string const &message,
     CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
 {
-    return ContainsMatcher(
+    return ContainsMatcher(CasedString(
-        CasedString(fmt::format("{} -> {} : {}()", from, from, message),
+        fmt::format("{} -> {} : {}()", from, from, message), caseSensitivity));
-            caseSensitivity));
 }
 
 ContainsMatcher HasCall(std::string const &from, std::string const &to,
     std::string const &message,
     CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
 {
-    return ContainsMatcher(
+    return ContainsMatcher(CasedString(
-        CasedString(fmt::format("{} -> {} : {}()", from, to, message),
+        fmt::format("{} -> {} : {}()", from, to, message), caseSensitivity));
-            caseSensitivity));
 }
 
 auto HasCallWithResponse(std::string const &from, std::string const &to,
@@ -141,10 +139,9 @@ auto HasCallWithResponse(std::string const &from, std::string const &to,
     CaseSensitive::Choice caseSensitivity = CaseSensitive::Yes)
 {
     return HasCallWithResultMatcher(
-        CasedString(fmt::format("{} -> {} : {}()", from, to, message),
-            caseSensitivity),
         CasedString(
-            fmt::format("{} --> {}", to, from), caseSensitivity));
+            fmt::format("{} -> {} : {}()", from, to, message), caseSensitivity),
+        CasedString(fmt::format("{} --> {}", to, from), caseSensitivity));
 }
 
 struct AliasMatcher {