EXSWHTEC-169 - Implement additional tests for Kernel Graph Node APIs (#7)

- Tidy up hipGraphAddKernelNode tests
- Tidy up hipGraphKernelNodeGetParams tests
- Tidy up hipGraphKernelNodeSetParams tests
- Tidy up hipGraphExecKernelNodeSetParams tests.
- Disable failing test sections on AMD.

catch/unit/graph/hipGraphAddKernelNode.cc

@@ -6,8 +6,10 @@ in the Software without restriction, including without limitation the rights
 to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
+
 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.
+
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
@@ -22,7 +24,6 @@ THE SOFTWARE.
 
 /* Test verifies hipGraphAddKernelNode API Negative scenarios.
  */
-
 TEST_CASE("Unit_hipGraphAddKernelNode_Negative") {
   constexpr int N = 1024;
   size_t NElem{N};
@@ -31,7 +32,6 @@ TEST_CASE("Unit_hipGraphAddKernelNode_Negative") {
   unsigned blocks = HipTest::setNumBlocks(blocksPerCU, threadsPerBlock, N);
   int *A_d, *B_d, *C_d;
   hipGraph_t graph;
-  hipError_t ret;
   hipGraphNode_t kNode;
   hipKernelNodeParams kNodeParams{};
   std::vector<hipGraphNode_t> dependencies;
@@ -41,61 +41,67 @@ TEST_CASE("Unit_hipGraphAddKernelNode_Negative") {
   HIP_CHECK(hipMalloc(&C_d, sizeof(int) * N));
   HIP_CHECK(hipGraphCreate(&graph, 0));
 
-  void* kernelArgs[] = {&A_d, &B_d, &C_d, reinterpret_cast<void *>(&NElem)};
-  kNodeParams.func = reinterpret_cast<void *>(HipTest::vectorADD<int>);
+  void* kernelArgs[] = {&A_d, &B_d, &C_d, reinterpret_cast<void*>(&NElem)};
+  kNodeParams.func = reinterpret_cast<void*>(HipTest::vectorADD<int>);
   kNodeParams.gridDim = dim3(blocks);
   kNodeParams.blockDim = dim3(threadsPerBlock);
-  kNodeParams.sharedMemBytes = 0;
-  kNodeParams.kernelParams = reinterpret_cast<void **>(kernelArgs);
-  kNodeParams.extra = nullptr;
+  kNodeParams.kernelParams = reinterpret_cast<void**>(kernelArgs);
 
   SECTION("Pass pGraphNode as nullptr") {
-    ret = hipGraphAddKernelNode(nullptr, graph, nullptr, 0, &kNodeParams);
-    REQUIRE(hipErrorInvalidValue == ret);
+    HIP_CHECK_ERROR(hipGraphAddKernelNode(nullptr, graph, nullptr, 0, &kNodeParams),
+                    hipErrorInvalidValue);
   }
+
   SECTION("Pass Graph as nullptr") {
-    ret = hipGraphAddKernelNode(&kNode, nullptr, nullptr, 0, &kNodeParams);
-    REQUIRE(hipErrorInvalidValue == ret);
+    HIP_CHECK_ERROR(hipGraphAddKernelNode(&kNode, nullptr, nullptr, 0, &kNodeParams),
+                    hipErrorInvalidValue);
   }
+
   SECTION("Pass invalid numDependencies") {
-    ret = hipGraphAddKernelNode(&kNode, graph, nullptr, 11, &kNodeParams);
-    REQUIRE(hipErrorInvalidValue == ret);
+    HIP_CHECK_ERROR(hipGraphAddKernelNode(&kNode, graph, nullptr, 11, &kNodeParams),
+                    hipErrorInvalidValue);
   }
+
   SECTION("Pass invalid numDependencies and valid list for dependencies") {
     HIP_CHECK(hipGraphAddKernelNode(&kNode, graph, nullptr, 0, &kNodeParams));
     dependencies.push_back(kNode);
-    ret = hipGraphAddKernelNode(&kNode, graph,
-              dependencies.data(), dependencies.size()+1, &kNodeParams);
-    REQUIRE(hipErrorInvalidValue == ret);
+    HIP_CHECK_ERROR(hipGraphAddKernelNode(&kNode, graph, dependencies.data(),
+                                          dependencies.size() + 1, &kNodeParams),
+                    hipErrorInvalidValue);
   }
+
   SECTION("Pass NodeParams as nullptr") {
-    ret = hipGraphAddKernelNode(&kNode, graph,
-              dependencies.data(), dependencies.size(), nullptr);
-    REQUIRE(hipErrorInvalidValue == ret);
+    HIP_CHECK_ERROR(
+        hipGraphAddKernelNode(&kNode, graph, dependencies.data(), dependencies.size(), nullptr),
+        hipErrorInvalidValue);
   }
-  SECTION("Pass NodeParams func datamember as nullptr") {
+
+#if HT_NVIDIA  // on AMD this returns hipErrorInvalidValue
+  SECTION("Pass NodeParams func data member as nullptr") {
     kNodeParams.func = nullptr;
-    ret = hipGraphAddKernelNode(&kNode, graph, nullptr, 0, &kNodeParams);
-    REQUIRE(hipSuccess != ret);
+    HIP_CHECK_ERROR(hipGraphAddKernelNode(&kNode, graph, nullptr, 0, &kNodeParams),
+                    hipErrorInvalidDeviceFunction);
   }
-  SECTION("Pass kernelParams datamember as nullptr") {
-    kNodeParams.func = reinterpret_cast<void *>(HipTest::vectorADD<int>);
+#endif
+
+  SECTION("Pass kernelParams data member as nullptr") {
     kNodeParams.kernelParams = nullptr;
-    ret = hipGraphAddKernelNode(&kNode, graph, nullptr, 0, &kNodeParams);
-    REQUIRE(hipErrorInvalidValue == ret);
+    HIP_CHECK_ERROR(hipGraphAddKernelNode(&kNode, graph, nullptr, 0, &kNodeParams),
+                    hipErrorInvalidValue);
   }
-#if HT_AMD
-// On Cuda setup this test case getting failed
+
+#if HT_AMD  // On Cuda setup this test case getting failed
   SECTION("Try adding kernel node after destroy the already created graph") {
-    kNodeParams.kernelParams = reinterpret_cast<void **>(kernelArgs);
-    HIP_CHECK(hipGraphDestroy(graph));
-    ret = hipGraphAddKernelNode(&kNode, graph, nullptr, 0, &kNodeParams);
-    REQUIRE(hipErrorInvalidValue == ret);
+    hipGraph_t destroyed_graph;
+    HIP_CHECK(hipGraphCreate(&destroyed_graph, 0));
+    HIP_CHECK(hipGraphDestroy(destroyed_graph));
+    HIP_CHECK_ERROR(hipGraphAddKernelNode(&kNode, destroyed_graph, nullptr, 0, &kNodeParams),
+                    hipErrorInvalidValue);
   }
 #endif
 
   HIP_CHECK(hipFree(A_d));
   HIP_CHECK(hipFree(B_d));
   HIP_CHECK(hipFree(C_d));
+  HIP_CHECK(hipGraphDestroy(graph));
 }
-