EXSWHTEC-178 - Implement tests for Graph Event Node APIs #44

Change-Id: Id3f569d94d347af2f5e27513fa01c5a1e8e30fd9

catch/unit/graph/hipGraphEventRecordNodeSetEvent.cc

@@ -30,14 +30,16 @@ Testcase Scenarios :
     - Input event parameter is nullptr.
     - Empty node is passed as input node.
     - Memset node is passed as input node.
+    - Event wait node is passed as input node.
     - Input node is an uninitialized node.
     - Input event is an uninitialized event.
 */
 
-#include <hip_test_common.hh>
 #include <hip_test_checkers.hh>
+#include <hip_test_common.hh>
 #include <hip_test_kernels.hh>
 
+
 /**
  * Local Function: Set Get test
  */
@@ -49,8 +51,7 @@ static void validateEventRecordNodeSetEvent(unsigned flag) {
   HIP_CHECK(hipEventCreate(&event1));
   HIP_CHECK(hipEventCreateWithFlags(&event2, flag));
   hipGraphNode_t eventrec;
-  HIP_CHECK(hipGraphAddEventRecordNode(&eventrec, graph, nullptr, 0,
-                                                            event1));
+  HIP_CHECK(hipGraphAddEventRecordNode(&eventrec, graph, nullptr, 0, event1));
   // Set a different event
   HIP_CHECK(hipGraphEventRecordNodeSetEvent(eventrec, event2));
   HIP_CHECK(hipGraphEventRecordNodeGetEvent(eventrec, &event_out));
@@ -73,11 +74,9 @@ static void setEventWaitNode() {
   HIP_CHECK(hipEventCreate(&event1));
   HIP_CHECK(hipEventCreate(&event2));
   hipGraphNode_t eventwait;
-  HIP_CHECK(hipGraphAddEventWaitNode(&eventwait, graph, nullptr, 0,
-                                                           event1));
+  HIP_CHECK(hipGraphAddEventWaitNode(&eventwait, graph, nullptr, 0, event1));
   // Set a different event eventwait using hipGraphEventRecordNodeSetEvent
-  REQUIRE(hipErrorInvalidValue ==
-          hipGraphEventRecordNodeSetEvent(eventwait, event2));
+  HIP_CHECK_ERROR(hipGraphEventRecordNodeSetEvent(eventwait, event2), hipErrorInvalidValue);
   // Free resources
   HIP_CHECK(hipGraphDestroy(graph));
   HIP_CHECK(hipEventDestroy(event1));
@@ -98,13 +97,11 @@ TEST_CASE("Unit_hipGraphEventRecordNodeSetEvent_SetEventProperty") {
   HIP_CHECK(hipEventCreateWithFlags(&event2_end, hipEventDisableTiming));
   // Create nodes
   hipGraphNode_t event_start_rec, event_end_rec;
-  HIP_CHECK(hipGraphAddEventRecordNode(&event_start_rec, graph, nullptr, 0,
-                                                          event1_start));
-  HIP_CHECK(hipGraphAddEventRecordNode(&event_end_rec, graph, nullptr, 0,
-                                                          event1_end));
+  HIP_CHECK(hipGraphAddEventRecordNode(&event_start_rec, graph, nullptr, 0, event1_start));
+  HIP_CHECK(hipGraphAddEventRecordNode(&event_end_rec, graph, nullptr, 0, event1_end));
   // Create memset node
   constexpr size_t Nbytes = 1024;
-  char *A_d;
+  char* A_d;
   hipGraphNode_t memset_A;
   hipMemsetParams memsetParams{};
   HIP_CHECK(hipMalloc(&A_d, Nbytes));
@@ -115,8 +112,7 @@ TEST_CASE("Unit_hipGraphEventRecordNodeSetEvent_SetEventProperty") {
   memsetParams.elementSize = sizeof(char);
   memsetParams.width = Nbytes;
   memsetParams.height = 1;
-  HIP_CHECK(hipGraphAddMemsetNode(&memset_A, graph, nullptr, 0,
-                                  &memsetParams));
+  HIP_CHECK(hipGraphAddMemsetNode(&memset_A, graph, nullptr, 0, &memsetParams));
   // Create dependencies
   // event_start_rec --> memset_A --> event_end_rec
   HIP_CHECK(hipGraphAddDependencies(graph, &event_start_rec, &memset_A, 1));
@@ -132,8 +128,7 @@ TEST_CASE("Unit_hipGraphEventRecordNodeSetEvent_SetEventProperty") {
   // Validate by measuring time difference between event_end_rec &
   // event_start_rec
   float t = 0.0f;
-  REQUIRE(hipSuccess == hipEventElapsedTime(&t, event1_start,
-                                            event1_end));
+  REQUIRE(hipSuccess == hipEventElapsedTime(&t, event1_start, event1_end));
   REQUIRE(t > 0.0f);
   // Change the event property after instantiation
   HIP_CHECK(hipGraphEventRecordNodeSetEvent(event_start_rec, event2_start));
@@ -145,8 +140,7 @@ TEST_CASE("Unit_hipGraphEventRecordNodeSetEvent_SetEventProperty") {
   // hipErrorInvalidHandle when events are created using
   // hipEventDisableTiming flag.
   t = 0.0f;
-  REQUIRE(hipErrorInvalidHandle ==
-          hipEventElapsedTime(&t, event2_start, event2_end));
+  HIP_CHECK_ERROR(hipEventElapsedTime(&t, event2_start, event2_end), hipErrorInvalidHandle);
   // Free resources
   HIP_CHECK(hipGraphExecDestroy(graphExec));
   HIP_CHECK(hipStreamDestroy(streamForGraph));
@@ -185,28 +179,24 @@ TEST_CASE("Unit_hipGraphEventRecordNodeSetEvent_Negative") {
   HIP_CHECK(hipEventCreate(&event1));
   HIP_CHECK(hipEventCreate(&event2));
   hipGraphNode_t eventrec;
-  HIP_CHECK(hipGraphAddEventRecordNode(&eventrec, graph, nullptr, 0,
-                                                            event1));
+  HIP_CHECK(hipGraphAddEventRecordNode(&eventrec, graph, nullptr, 0, event1));
   SECTION("node = nullptr") {
-    REQUIRE(hipErrorInvalidValue == hipGraphEventRecordNodeSetEvent(nullptr,
-                                    event2));
+    HIP_CHECK_ERROR(hipGraphEventRecordNodeSetEvent(nullptr, event2), hipErrorInvalidValue);
   }
 
   SECTION("event_out = nullptr") {
-    REQUIRE(hipErrorInvalidValue == hipGraphEventRecordNodeSetEvent(eventrec,
-                                    nullptr));
+    HIP_CHECK_ERROR(hipGraphEventRecordNodeSetEvent(eventrec, nullptr), hipErrorInvalidValue);
   }
 
   SECTION("input node is empty node") {
     hipGraphNode_t EmptyGraphNode;
     HIP_CHECK(hipGraphAddEmptyNode(&EmptyGraphNode, graph, nullptr, 0));
-    REQUIRE(hipErrorInvalidValue ==
-            hipGraphEventRecordNodeSetEvent(EmptyGraphNode, event2));
+    HIP_CHECK_ERROR(hipGraphEventRecordNodeSetEvent(EmptyGraphNode, event2), hipErrorInvalidValue);
   }
 
   SECTION("input node is memset node") {
     constexpr size_t Nbytes = 1024;
-    char *A_d;
+    char* A_d;
     hipGraphNode_t memset_A;
     hipMemsetParams memsetParams{};
     HIP_CHECK(hipMalloc(&A_d, Nbytes));
@@ -217,10 +207,8 @@ TEST_CASE("Unit_hipGraphEventRecordNodeSetEvent_Negative") {
     memsetParams.elementSize = sizeof(char);
     memsetParams.width = Nbytes;
     memsetParams.height = 1;
-    HIP_CHECK(hipGraphAddMemsetNode(&memset_A, graph, nullptr, 0,
-                                    &memsetParams));
-    REQUIRE(hipErrorInvalidValue ==
-            hipGraphEventRecordNodeSetEvent(memset_A, event2));
+    HIP_CHECK(hipGraphAddMemsetNode(&memset_A, graph, nullptr, 0, &memsetParams));
+    HIP_CHECK_ERROR(hipGraphEventRecordNodeSetEvent(memset_A, event2), hipErrorInvalidValue);
     HIP_CHECK(hipFree(A_d));
   }
 
@@ -230,14 +218,12 @@ TEST_CASE("Unit_hipGraphEventRecordNodeSetEvent_Negative") {
 
   SECTION("input node is uninitialized node") {
     hipGraphNode_t node_uninit{};
-    REQUIRE(hipErrorInvalidValue ==
-            hipGraphEventRecordNodeSetEvent(node_uninit, event2));
+    HIP_CHECK_ERROR(hipGraphEventRecordNodeSetEvent(node_uninit, event2), hipErrorInvalidValue);
   }
 
   SECTION("input event is uninitialized") {
     hipEvent_t event_uninit{};
-    REQUIRE(hipErrorInvalidValue ==
-            hipGraphEventRecordNodeSetEvent(eventrec, event_uninit));
+    HIP_CHECK_ERROR(hipGraphEventRecordNodeSetEvent(eventrec, event_uninit), hipErrorInvalidValue);
   }
 
   HIP_CHECK(hipGraphDestroy(graph));