Fix a few minor bugs in USM related enqueue tests.

Author: aarongreig

test/conformance/enqueue/urEnqueueUSMFill.cpp

@@ -167,57 +167,50 @@ TEST_P(urEnqueueUSMFillNegativeTest, InvalidNullPtr) {
 }
 
 TEST_P(urEnqueueUSMFillNegativeTest, InvalidSize) {
-
     /* size is 0 */
-    ASSERT_EQ_RESULT(urEnqueueUSMFill(queue, nullptr, pattern_size,
-                                      pattern.data(), 0, 0, nullptr, nullptr),
+    ASSERT_EQ_RESULT(urEnqueueUSMFill(queue, ptr, pattern_size, pattern.data(),
+                                      0, 0, nullptr, nullptr),
                      UR_RESULT_ERROR_INVALID_SIZE);
 
     /* size is not a multiple of pattern_size */
-    ASSERT_EQ_RESULT(urEnqueueUSMFill(queue, nullptr, pattern_size,
-                                      pattern.data(), 7, 0, nullptr, nullptr),
+    ASSERT_EQ_RESULT(urEnqueueUSMFill(queue, ptr, pattern_size, pattern.data(),
+                                      7, 0, nullptr, nullptr),
                      UR_RESULT_ERROR_INVALID_SIZE);
 }
 
 TEST_P(urEnqueueUSMFillNegativeTest, OutOfBounds) {
-
     size_t out_of_bounds = size + 1;
-    ASSERT_EQ_RESULT(urEnqueueUSMFill(queue, nullptr, pattern_size,
-                                      pattern.data(), out_of_bounds, 0, nullptr,
-                                      nullptr),
+    ASSERT_EQ_RESULT(urEnqueueUSMFill(queue, ptr, pattern_size, pattern.data(),
+                                      out_of_bounds, 0, nullptr, nullptr),
                      UR_RESULT_ERROR_INVALID_SIZE);
 }
 
 TEST_P(urEnqueueUSMFillNegativeTest, invalidPatternSize) {
-
     /* pattern_size is 0 */
-    ASSERT_EQ_RESULT(urEnqueueUSMFill(queue, nullptr, 0, pattern.data(), size,
-                                      0, nullptr, nullptr),
+    ASSERT_EQ_RESULT(urEnqueueUSMFill(queue, ptr, 0, pattern.data(), size, 0,
+                                      nullptr, nullptr),
                      UR_RESULT_ERROR_INVALID_SIZE);
 
     /* pattern_size is not a power of 2 */
-    ASSERT_EQ_RESULT(urEnqueueUSMFill(queue, nullptr, 3, pattern.data(), size,
-                                      0, nullptr, nullptr),
+    ASSERT_EQ_RESULT(urEnqueueUSMFill(queue, ptr, 3, pattern.data(), size, 0,
+                                      nullptr, nullptr),
                      UR_RESULT_ERROR_INVALID_SIZE);
 
     /* pattern_size is larger than size */
-    ASSERT_EQ_RESULT(urEnqueueUSMFill(queue, nullptr, 32, pattern.data(), size,
-                                      0, nullptr, nullptr),
+    ASSERT_EQ_RESULT(urEnqueueUSMFill(queue, ptr, 32, pattern.data(), size, 0,
+                                      nullptr, nullptr),
                      UR_RESULT_ERROR_INVALID_SIZE);
 }
 
-TEST_P(urEnqueueUSMFillNegativeTest, InvalidNullPtrEventWaitList) {
-
-    ASSERT_EQ_RESULT(urEnqueueUSMFill(queue, nullptr, pattern_size,
-                                      pattern.data(), size, 1, nullptr,
-                                      nullptr),
+TEST_P(urEnqueueUSMFillNegativeTest, InvalidEventWaitList) {
+    ASSERT_EQ_RESULT(urEnqueueUSMFill(queue, ptr, pattern_size, pattern.data(),
+                                      size, 1, nullptr, nullptr),
                      UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 
     ur_event_handle_t validEvent;
     ASSERT_SUCCESS(urEnqueueEventsWait(queue, 0, nullptr, &validEvent));
 
-    ASSERT_EQ_RESULT(urEnqueueUSMFill(queue, nullptr, pattern_size,
-                                      pattern.data(), size, 0, &validEvent,
-                                      nullptr),
+    ASSERT_EQ_RESULT(urEnqueueUSMFill(queue, ptr, pattern_size, pattern.data(),
+                                      size, 0, &validEvent, nullptr),
                      UR_RESULT_ERROR_INVALID_EVENT_WAIT_LIST);
 }

test/conformance/enqueue/urEnqueueUSMFill2D.cpp

@@ -205,7 +205,6 @@ TEST_P(urEnqueueUSMFill2DNegativeTest, InvalidNullPtr) {
 }
 
 TEST_P(urEnqueueUSMFill2DNegativeTest, InvalidPitch) {
-
     ASSERT_EQ_RESULT(urEnqueueUSMFill2D(queue, ptr, 0, pattern_size,
                                         pattern.data(), width, height, 0,
                                         nullptr, nullptr),
@@ -218,30 +217,30 @@ TEST_P(urEnqueueUSMFill2DNegativeTest, InvalidPitch) {
 }
 
 TEST_P(urEnqueueUSMFill2DNegativeTest, InvalidWidth) {
-
     /* width is 0 */
     ASSERT_EQ_RESULT(urEnqueueUSMFill2D(queue, ptr, pitch, pattern_size,
                                         pattern.data(), 0, height, 0, nullptr,
                                         nullptr),
                      UR_RESULT_ERROR_INVALID_SIZE);
+}
 
-    /* width is not a multiple of pattern_size */
+TEST_P(urEnqueueUSMFill2DNegativeTest, InvalidHeight) {
+    /* height is 0 */
     ASSERT_EQ_RESULT(urEnqueueUSMFill2D(queue, ptr, pitch, pattern_size,
-                                        pattern.data(), 7, height, 0, nullptr,
+                                        pattern.data(), width, 0, 0, nullptr,
                                         nullptr),
                      UR_RESULT_ERROR_INVALID_SIZE);
 }
 
-TEST_P(urEnqueueUSMFill2DNegativeTest, InvalidHeight) {
-
+TEST_P(urEnqueueUSMFill2DNegativeTest, InvalidSize) {
+    /* width * height is not a multiple of pattern_size */
     ASSERT_EQ_RESULT(urEnqueueUSMFill2D(queue, ptr, pitch, pattern_size,
-                                        pattern.data(), width, 0, 0, nullptr,
-                                        nullptr),
+                                        pattern.data(), width - 1, width - 1, 0,
+                                        nullptr, nullptr),
                      UR_RESULT_ERROR_INVALID_SIZE);
 }
 
 TEST_P(urEnqueueUSMFill2DNegativeTest, OutOfBounds) {
-
     size_t out_of_bounds = pitch * height + 1;
 
     /* Interpret memory as having just one row */
@@ -258,7 +257,6 @@ TEST_P(urEnqueueUSMFill2DNegativeTest, OutOfBounds) {
 }
 
 TEST_P(urEnqueueUSMFill2DNegativeTest, invalidPatternSize) {
-
     /* pattern size is 0 */
     ASSERT_EQ_RESULT(urEnqueueUSMFill2D(queue, ptr, pitch, 0, pattern.data(),
                                         width, 1, 0, nullptr, nullptr),
@@ -276,7 +274,6 @@ TEST_P(urEnqueueUSMFill2DNegativeTest, invalidPatternSize) {
 }
 
 TEST_P(urEnqueueUSMFill2DNegativeTest, InvalidNullPtrEventWaitList) {
-
     ASSERT_EQ_RESULT(urEnqueueUSMFill2D(queue, ptr, pitch, pattern_size,
                                         pattern.data(), width, 1, 1, nullptr,
                                         nullptr),

test/conformance/enqueue/urEnqueueUSMMemcpy.cpp

@@ -125,7 +125,8 @@ TEST_P(urEnqueueUSMMemcpyTest, NonBlocking) {
  */
 TEST_P(urEnqueueUSMMemcpyTest, WaitForDependencies) {
     ASSERT_SUCCESS(urEnqueueUSMMemcpy(queue, true, device_dst, device_src,
-                                      sizeof(int), 1, &memset_event, nullptr));
+                                      allocation_size, 1, &memset_event,
+                                      nullptr));
     ASSERT_TRUE(memsetHasFinished());
     ASSERT_NO_FATAL_FAILURE(verifyData());
 }