SWDEV-470698 - fix formatting, add format check workflow (#657)

projects/hip-tests/catch/unit/graph/hipGraphExecMemcpyNodeSetParamsToSymbol.cc

@@ -36,27 +36,24 @@ HIP_GRAPH_MEMCPY_FROM_SYMBOL_NODE_DEFINE_ALTERNATE_GLOBALS(float)
 HIP_GRAPH_MEMCPY_FROM_SYMBOL_NODE_DEFINE_ALTERNATE_GLOBALS(double)
 
 template <typename T>
-void GraphExecMemcpyToSymbolSetParamsShell(const void *symbol,
-                                           const void *alt_symbol,
-                                           size_t offset,
-                                           const std::vector<T> set_values) {
-  const auto f = [alt_symbol, is_arr = set_values.size() > 1](
-                     const void *symbol, void *src, size_t count, size_t offset,
-                     hipMemcpyKind direction) {
+void GraphExecMemcpyToSymbolSetParamsShell(const void* symbol, const void* alt_symbol,
+                                           size_t offset, const std::vector<T> set_values) {
+  const auto f = [alt_symbol, is_arr = set_values.size() > 1](const void* symbol, void* src,
+                                                              size_t count, size_t offset,
+                                                              hipMemcpyKind direction) {
     hipGraph_t graph = nullptr;
     HIP_CHECK(hipGraphCreate(&graph, 0));
 
     hipGraphNode_t node = nullptr;
     HIP_CHECK(hipGraphAddMemcpyNodeToSymbol(
-        &node, graph, nullptr, 0, alt_symbol,
-        reinterpret_cast<T *>(src) + is_arr, count - is_arr * sizeof(T),
-        offset + is_arr * sizeof(T), direction));
+        &node, graph, nullptr, 0, alt_symbol, reinterpret_cast<T*>(src) + is_arr,
+        count - is_arr * sizeof(T), offset + is_arr * sizeof(T), direction));
 
     hipGraphExec_t graph_exec = nullptr;
     HIP_CHECK(hipGraphInstantiate(&graph_exec, graph, nullptr, nullptr, 0));
 
-    HIP_CHECK(hipGraphExecMemcpyNodeSetParamsToSymbol(
-        graph_exec, node, symbol, src, count, offset, direction));
+    HIP_CHECK(hipGraphExecMemcpyNodeSetParamsToSymbol(graph_exec, node, symbol, src, count, offset,
+                                                      direction));
 
     HIP_CHECK(hipGraphLaunch(graph_exec, hipStreamPerThread));
     HIP_CHECK(hipStreamSynchronize(hipStreamPerThread));
@@ -103,23 +100,23 @@ void GraphExecMemcpyToSymbolSetParamsShell(const void *symbol,
  */
 TEST_CASE("Unit_hipGraphExecMemcpyNodeSetParamsToSymbol_Positive_Basic") {
   SECTION("char") {
-    HIP_GRAPH_MEMCPY_NODE_SET_PARAMS_TO_FROM_SYMBOL_TEST(
-        GraphExecMemcpyToSymbolSetParamsShell, 10, char);
+    HIP_GRAPH_MEMCPY_NODE_SET_PARAMS_TO_FROM_SYMBOL_TEST(GraphExecMemcpyToSymbolSetParamsShell, 10,
+                                                         char);
   }
 
   SECTION("int") {
-    HIP_GRAPH_MEMCPY_NODE_SET_PARAMS_TO_FROM_SYMBOL_TEST(
-        GraphExecMemcpyToSymbolSetParamsShell, 10, int);
+    HIP_GRAPH_MEMCPY_NODE_SET_PARAMS_TO_FROM_SYMBOL_TEST(GraphExecMemcpyToSymbolSetParamsShell, 10,
+                                                         int);
   }
 
   SECTION("float") {
-    HIP_GRAPH_MEMCPY_NODE_SET_PARAMS_TO_FROM_SYMBOL_TEST(
-        GraphExecMemcpyToSymbolSetParamsShell, 10, float);
+    HIP_GRAPH_MEMCPY_NODE_SET_PARAMS_TO_FROM_SYMBOL_TEST(GraphExecMemcpyToSymbolSetParamsShell, 10,
+                                                         float);
   }
 
   SECTION("double") {
-    HIP_GRAPH_MEMCPY_NODE_SET_PARAMS_TO_FROM_SYMBOL_TEST(
-        GraphExecMemcpyToSymbolSetParamsShell, 10, double);
+    HIP_GRAPH_MEMCPY_NODE_SET_PARAMS_TO_FROM_SYMBOL_TEST(GraphExecMemcpyToSymbolSetParamsShell, 10,
+                                                         double);
   }
 }
 
@@ -152,37 +149,35 @@ TEST_CASE("Unit_hipGraphExecMemcpyNodeSetParamsToSymbol_Negative_Parameters") {
 
   LinearAllocGuard<int> var(LinearAllocs::hipMalloc, sizeof(int));
   hipGraphNode_t node = nullptr;
-  HIP_CHECK(hipGraphAddMemcpyNodeToSymbol(
-      &node, graph, nullptr, 0, SYMBOL(int_device_var), var.ptr(),
-      sizeof(*var.ptr()), 0, hipMemcpyDefault));
+  HIP_CHECK(hipGraphAddMemcpyNodeToSymbol(&node, graph, nullptr, 0, SYMBOL(int_device_var),
+                                          var.ptr(), sizeof(*var.ptr()), 0, hipMemcpyDefault));
 
   hipGraphExec_t graph_exec = nullptr;
   HIP_CHECK(hipGraphInstantiate(&graph_exec, graph, nullptr, nullptr, 0));
 
   SECTION("hGraphExec == nullptr") {
-    HIP_CHECK_ERROR(hipGraphExecMemcpyNodeSetParamsToSymbol(
-                        nullptr, node, SYMBOL(int_device_var), var.ptr(),
-                        sizeof(*var.ptr()), 0, hipMemcpyDefault),
-                    hipErrorInvalidValue);
+    HIP_CHECK_ERROR(
+        hipGraphExecMemcpyNodeSetParamsToSymbol(nullptr, node, SYMBOL(int_device_var), var.ptr(),
+                                                sizeof(*var.ptr()), 0, hipMemcpyDefault),
+        hipErrorInvalidValue);
   }
 
   SECTION("node == nullptr") {
-    HIP_CHECK_ERROR(hipGraphExecMemcpyNodeSetParamsToSymbol(
-                        graph_exec, nullptr, SYMBOL(int_device_var), var.ptr(),
-                        sizeof(*var.ptr()), 0, hipMemcpyDefault),
-                    hipErrorInvalidValue);
+    HIP_CHECK_ERROR(
+        hipGraphExecMemcpyNodeSetParamsToSymbol(graph_exec, nullptr, SYMBOL(int_device_var),
+                                                var.ptr(), sizeof(*var.ptr()), 0, hipMemcpyDefault),
+        hipErrorInvalidValue);
   }
 
   MemcpyToSymbolCommonNegative(
-      std::bind(hipGraphExecMemcpyNodeSetParamsToSymbol, graph_exec, node, _1,
-                _2, _3, _4, _5),
+      std::bind(hipGraphExecMemcpyNodeSetParamsToSymbol, graph_exec, node, _1, _2, _3, _4, _5),
       SYMBOL(int_device_var), var.ptr(), sizeof(*var.ptr()));
 
   SECTION("Changing memcpy direction") {
-    HIP_CHECK_ERROR(hipGraphExecMemcpyNodeSetParamsToSymbol(
-                        graph_exec, node, SYMBOL(int_device_var), var.ptr(),
-                        sizeof(*var.ptr()), 0, hipMemcpyHostToDevice),
-                    hipErrorInvalidValue);
+    HIP_CHECK_ERROR(
+        hipGraphExecMemcpyNodeSetParamsToSymbol(graph_exec, node, SYMBOL(int_device_var), var.ptr(),
+                                                sizeof(*var.ptr()), 0, hipMemcpyHostToDevice),
+        hipErrorInvalidValue);
   }
 
   SECTION("Changing src allocation device") {
@@ -192,9 +187,9 @@ TEST_CASE("Unit_hipGraphExecMemcpyNodeSetParamsToSymbol_Negative_Parameters") {
       HIP_CHECK(hipSetDevice(1));
       LinearAllocGuard<int> new_var(LinearAllocs::hipMalloc, sizeof(int));
       HIP_CHECK_ERROR(hipGraphExecMemcpyNodeSetParamsToSymbol(
-                          graph_exec, node, SYMBOL(int_device_var),
-                          new_var.ptr(), sizeof(*new_var.ptr()),
-                          0, hipMemcpyDefault), hipErrorInvalidValue);
+                          graph_exec, node, SYMBOL(int_device_var), new_var.ptr(),
+                          sizeof(*new_var.ptr()), 0, hipMemcpyDefault),
+                      hipErrorInvalidValue);
     }
   }