clang-format and clang-tidy fixes for aebae1df

search/sublist_search.cpp

@@ -39,38 +39,39 @@ namespace search {
  * Search](https://www.geeksforgeeks.org/sublist-search-search-a-linked-list-in-another-list)
  * implementation
  */
-    namespace sublist_search {
+namespace sublist_search {
 /**
  * @brief A Node structure representing a single link Node in a linked list
  */
-        struct Node {
+struct Node {
     uint32_t data = 0;  ///< the key/value of the node
     Node *next{};       ///< pointer to the next node
-        };
+};
 
 /**
  * @brief A simple function to print the linked list
  * @param start The head of the linked list
  * @returns void
  */
-        void printLinkedList(Node *start) {
+void printLinkedList(Node *start) {
     while (start != nullptr) {
         std::cout << "->" << start->data;
         start = start->next;
     }
     std::cout << std::endl;
-        }
+}
 
 /**
  * @brief Give a vector of data,
- * it adds each element of vector in the linked list and return the address of head pointer.
+ * it adds each element of vector in the linked list and return the address of
+ * head pointer.
  * @param data A vector of "int" containing the data that is supposed to be
  * stored in nodes of linked list.
  * @returns Node* A head pointer to the linked list.
  */
-        Node *makeLinkedList(const std::vector<uint64_t> &data) {
+Node *makeLinkedList(const std::vector<uint64_t> &data) {
-            /// This is used in test cases for rapidly creating linked list with 100+ elements, instead of hard-coding
+    /// This is used in test cases for rapidly creating linked list with 100+
-            /// 100 elements in test cases.
+    /// elements, instead of hard-coding 100 elements in test cases.
     Node *head = nullptr;
     Node *tail = nullptr;
     for (int i : data) {
@@ -86,7 +87,7 @@ namespace search {
         }
     }
     return head;
-        }
+}
 
 /**
  * @brief Main searching function
@@ -95,7 +96,7 @@ namespace search {
  * @returns true if the sublist is found
  * @returns false if the sublist is NOT found
  */
-        bool sublistSearch(Node *sublist, Node *mainList) {
+bool sublistSearch(Node *sublist, Node *mainList) {
     if (sublist == nullptr || mainList == nullptr) {
         return false;
     }
@@ -123,31 +124,33 @@ namespace search {
         }
 
         if (target_ptr == nullptr) {
-                    /// Is target pointer becomes null that means the target list is been
+            /// Is target pointer becomes null that means the target list is
-                    /// traversed without returning false. Which means the sublist has
+            /// been traversed without returning false. Which means the sublist
-                    /// been found and return ture.
+            /// has been found and return ture.
             return true;
         }
 
         /// set the target pointer again to stating point of target list.
         target_ptr = sublist;
 
-                /// set the main pointer to the next element of the main list and repeat the algo.
+        /// set the main pointer to the next element of the main list and repeat
+        /// the algo.
         mainList = mainList->next;
     }
 
-            /// If the main list is exhausted, means sublist does not found, return false
+    /// If the main list is exhausted, means sublist does not found, return
+    /// false
     return false;
-        }
+}
 
-    }  // namespace sublist_search
+}  // namespace sublist_search
 }  // namespace search
 
 /**
  * @brief class encapsulating the necessary test cases
  */
 class TestCases {
-private:
+ private:
     /**
      * @brief A function to print given message on console.
      * @tparam T Type of the given message.
@@ -159,7 +162,7 @@ private:
         std::cout << "[TESTS] : ---> " << msg << std::endl;
     }
 
-public:
+ public:
     /**
      * @brief Executes test cases
      * @returns void
@@ -188,13 +191,18 @@ public:
         log("Description:");
         log("   EDGE CASE : Only contains one element");
 
-        std::vector<uint64_t> sublistData = {6};  /// Data to make linked list which will be the sublist
+        std::vector<uint64_t> sublistData = {
-        std::vector<uint64_t> mainlistData = {2, 5, 6, 7, 8};  /// Data to make linked list which will be the main list
+            6};  /// Data to make linked list which will be the sublist
+        std::vector<uint64_t> mainlistData = {
+            2, 5, 6, 7,
+            8};  /// Data to make linked list which will be the main list
 
         search::sublist_search::Node *sublistLL =
-                search::sublist_search::makeLinkedList(sublistData);  /// Sublist to be searched
+            search::sublist_search::makeLinkedList(
+                sublistData);  /// Sublist to be searched
         search::sublist_search::Node *mainlistLL =
-                search::sublist_search::makeLinkedList(mainlistData);  /// Main list in which sublist is to be searched
+            search::sublist_search::makeLinkedList(
+                mainlistData);  /// Main list in which sublist is to be searched
 
         bool exists = search::sublist_search::sublistSearch(
             sublistLL, mainlistLL);  /// boolean, if sublist exist or not
@@ -219,13 +227,16 @@ public:
     void testCase_2() {
         const bool expectedOutput = true;  /// Expected output of this test
 
-        log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
+        log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
+            "~");
         log("This is test case 2 for sublist search Algorithm : ");
         log("Description:");
         log("   contains main list of 100 elements and sublist of 20");
 
-        std::vector<uint64_t> sublistData(20);  /// Data to make linked list which will be the sublist
+        std::vector<uint64_t> sublistData(
-        std::vector<uint64_t> mainlistData(100); /// Main list in which sublist is to be searched
+            20);  /// Data to make linked list which will be the sublist
+        std::vector<uint64_t> mainlistData(
+            100);  /// Main list in which sublist is to be searched
 
         for (int i = 0; i < 100; i++) {
             /// Inserts 100 elements in main list
@@ -240,9 +251,11 @@ public:
         }
 
         search::sublist_search::Node *sublistLL =
-                search::sublist_search::makeLinkedList(sublistData);  /// Sublist to be searched
+            search::sublist_search::makeLinkedList(
+                sublistData);  /// Sublist to be searched
         search::sublist_search::Node *mainlistLL =
-                search::sublist_search::makeLinkedList(mainlistData);  /// Main list in which sublist is to be searched
+            search::sublist_search::makeLinkedList(
+                mainlistData);  /// Main list in which sublist is to be searched
 
         bool exists = search::sublist_search::sublistSearch(
             sublistLL, mainlistLL);  // boolean, if sublist exist or not
@@ -252,7 +265,8 @@ public:
         log("Assertion check passed!");
 
         log("[PASS] : TEST CASE 2 PASS!");
-        log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
+        log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
+            "~");
     }
 
     /**
@@ -263,13 +277,15 @@ public:
     void testCase_3() {
         const bool expectedOutput = false;  /// Expected output of this test
 
-        log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
+        log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
+            "~");
         log("This is test case 3 for sublist search Algorithm : ");
         log("Description:");
         log("   contains main list of 50 elements and sublist of 20");
 
         std::vector<uint64_t> sublistData(20);  /// Sublist to be searched
-        std::vector<uint64_t> mainlistData(50);  /// Main list in which sublist is to be searched
+        std::vector<uint64_t> mainlistData(
+            50);  /// Main list in which sublist is to be searched
 
         for (int i = 0; i < 50; i++) {
             /// Inserts 100 elements in main list
@@ -282,9 +298,11 @@ public:
         }
 
         search::sublist_search::Node *sublistLL =
-                search::sublist_search::makeLinkedList(sublistData);  /// Sublist to be searched
+            search::sublist_search::makeLinkedList(
+                sublistData);  /// Sublist to be searched
         search::sublist_search::Node *mainlistLL =
-                search::sublist_search::makeLinkedList(mainlistData);  /// Main list in which sublist is to be searched
+            search::sublist_search::makeLinkedList(
+                mainlistData);  /// Main list in which sublist is to be searched
 
         bool exists = search::sublist_search::sublistSearch(
             sublistLL, mainlistLL);  /// boolean, if sublist exist or not
@@ -294,7 +312,8 @@ public:
         log("Assertion check passed!");
 
         log("[PASS] : TEST CASE 3 PASS!");
-        log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~");
+        log("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
+            "~");
     }
 };