Update cts tests.

Author: aarongreig

source/adapters/level_zero/context.cpp

@@ -159,7 +159,7 @@ ur_result_t urContextCreateWithNativeHandle(
     const ur_context_native_properties_t *Properties,
     /// [out] pointer to the handle of the context object created.
     ur_context_handle_t *Context) {
-  bool OwnNativeHandle = Properties->isNativeHandleOwned;
+  bool OwnNativeHandle = Properties ? Properties->isNativeHandleOwned : false;
   try {
     ze_context_handle_t ZeContext =
         reinterpret_cast<ze_context_handle_t>(NativeContext);

source/adapters/level_zero/memory.cpp

@@ -1639,8 +1639,9 @@ ur_result_t urMemImageCreateWithNativeHandle(
     return Res;
   }
 
-  UR_CALL(createUrMemFromZeImage(
-      Context, ZeHImage, Properties->isNativeHandleOwned, ZeImageDesc, Mem));
+  auto OwnNativeHandle = Properties ? Properties->isNativeHandleOwned : false;
+  UR_CALL(createUrMemFromZeImage(Context, ZeHImage, OwnNativeHandle,
+                                 ZeImageDesc, Mem));
 
   return UR_RESULT_SUCCESS;
 }

test/conformance/event/urEventCreateWithNativeHandle.cpp

@@ -33,3 +33,26 @@ TEST_P(urEventCreateWithNativeHandleTest, Success) {
                                 sizeof(ur_execution_info_t), &exec_info,
                                 nullptr));
 }
+
+TEST_P(urEventCreateWithNativeHandleTest, SuccessWithProperties) {
+  ur_native_handle_t native_event = 0;
+  {
+    UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(
+        urEventGetNativeHandle(event, &native_event));
+  }
+
+  uur::raii::Event evt = nullptr;
+  // We can't pass isNativeHandleOwned = true in the generic tests since
+  // we always get the native handle from a UR object, and transferring
+  // ownership from one UR object to another isn't allowed.
+  ur_event_native_properties_t props = {
+      UR_STRUCTURE_TYPE_EVENT_NATIVE_PROPERTIES, nullptr, false};
+  UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(
+      urEventCreateWithNativeHandle(native_event, context, &props, evt.ptr()));
+  ASSERT_NE(evt, nullptr);
+
+  ur_execution_info_t exec_info;
+  ASSERT_SUCCESS(urEventGetInfo(evt, UR_EVENT_INFO_COMMAND_EXECUTION_STATUS,
+                                sizeof(ur_execution_info_t), &exec_info,
+                                nullptr));
+}

test/conformance/kernel/urKernelCreateWithNativeHandle.cpp

@@ -14,15 +14,11 @@ struct urKernelCreateWithNativeHandleTest : uur::urKernelTest {
         urKernelGetNativeHandle(kernel, &native_kernel_handle));
   }
 
-  void TearDown() override {
-    if (native_kernel) {
-      EXPECT_SUCCESS(urKernelRelease(native_kernel));
-    }
-    UUR_RETURN_ON_FATAL_FAILURE(urKernelTest::TearDown());
-  }
-
   ur_native_handle_t native_kernel_handle = 0;
   ur_kernel_handle_t native_kernel = nullptr;
+  // We can't pass isNativeHandleOwned = true in the generic tests since
+  // we always get the native handle from a UR object, and transferring
+  // ownership from one UR object to another isn't allowed.
   ur_kernel_native_properties_t properties = {
       UR_STRUCTURE_TYPE_KERNEL_NATIVE_PROPERTIES, /*sType*/
       nullptr,                                    /*pNext*/
@@ -32,6 +28,17 @@ struct urKernelCreateWithNativeHandleTest : uur::urKernelTest {
 UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urKernelCreateWithNativeHandleTest);
 
 TEST_P(urKernelCreateWithNativeHandleTest, Success) {
+  UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(urKernelCreateWithNativeHandle(
+      native_kernel_handle, context, program, nullptr, &native_kernel));
+
+  uint32_t ref_count = 0;
+  ASSERT_SUCCESS(urKernelGetInfo(native_kernel, UR_KERNEL_INFO_REFERENCE_COUNT,
+                                 sizeof(ref_count), &ref_count, nullptr));
+
+  ASSERT_NE(ref_count, 0);
+}
+
+TEST_P(urKernelCreateWithNativeHandleTest, SuccessWithProperties) {
   UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(urKernelCreateWithNativeHandle(
       native_kernel_handle, context, program, &properties, &native_kernel));
 

test/conformance/memory/urMemBufferCreateWithNativeHandle.cpp

@@ -32,26 +32,29 @@ TEST_P(urMemBufferCreateWithNativeHandleTest, Success) {
   ASSERT_SUCCESS(urMemRelease(mem));
 }
 
-TEST_P(urMemBufferCreateWithNativeHandleTest, SuccessWithOwnedNativeHandle) {
-  ur_native_handle_t native_handle = 0;
+TEST_P(urMemBufferCreateWithNativeHandleTest, SuccessWithProperties) {
+  ur_native_handle_t hNativeMem = 0;
   UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(
-      urMemGetNativeHandle(buffer, device, &native_handle));
+      urMemGetNativeHandle(buffer, device, &hNativeMem));
 
   ur_mem_handle_t mem = nullptr;
+  // We can't pass isNativeHandleOwned = true in the generic tests since
+  // we always get the native handle from a UR object, and transferring
+  // ownership from one UR object to another isn't allowed.
   ur_mem_native_properties_t props = {
       /*.stype =*/UR_STRUCTURE_TYPE_MEM_NATIVE_PROPERTIES,
       /*.pNext =*/nullptr,
-      /*.isNativeHandleOwned =*/true,
+      /*.isNativeHandleOwned =*/false,
   };
-  UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(
-      urMemBufferCreateWithNativeHandle(native_handle, context, &props, &mem));
-  ASSERT_NE(nullptr, mem);
+  ASSERT_SUCCESS(
+      urMemBufferCreateWithNativeHandle(hNativeMem, context, &props, &mem));
+  ASSERT_NE(mem, nullptr);
 
-  ur_context_handle_t mem_context = nullptr;
-  ASSERT_SUCCESS(urMemGetInfo(mem, UR_MEM_INFO_CONTEXT,
-                              sizeof(ur_context_handle_t), &mem_context,
-                              nullptr));
-  ASSERT_EQ(context, mem_context);
+  size_t alloc_size = 0;
+  ASSERT_SUCCESS(urMemGetInfo(mem, UR_MEM_INFO_SIZE, sizeof(size_t),
+                              &alloc_size, nullptr));
+
+  ASSERT_SUCCESS(urMemRelease(mem));
 }
 
 TEST_P(urMemBufferCreateWithNativeHandleTest, SuccessWithUnOwnedNativeHandle) {

test/conformance/memory/urMemImageCreateWithNativeHandle.cpp

@@ -16,7 +16,13 @@ struct urMemImageCreateWithNativeHandleTest : uur::urMemImageTest {
 UUR_INSTANTIATE_DEVICE_TEST_SUITE_P(urMemImageCreateWithNativeHandleTest);
 
 TEST_P(urMemImageCreateWithNativeHandleTest, Success) {
+<<<<<<< HEAD
   UUR_KNOWN_FAILURE_ON(uur::HIP{}, uur::LevelZero{});
+=======
+  ur_native_handle_t native_handle = 0;
+  UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(
+      urMemGetNativeHandle(image, device, &native_handle));
+>>>>>>> a2dab68a (Update cts tests.)
 
   ur_native_handle_t native_handle = 0;
   UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(
@@ -34,6 +40,28 @@ TEST_P(urMemImageCreateWithNativeHandleTest, Success) {
   ASSERT_EQ(context, mem_context);
 }
 
+TEST_P(urMemImageCreateWithNativeHandleTest, SuccessWithProperties) {
+  ur_native_handle_t native_handle = 0;
+  UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(
+      urMemGetNativeHandle(image, device, &native_handle));
+
+  ur_mem_handle_t mem = nullptr;
+  ur_mem_native_properties_t props = {UR_STRUCTURE_TYPE_MEM_NATIVE_PROPERTIES,
+                                      nullptr, false};
+  // We can't pass isNativeHandleOwned = true in the generic tests since
+  // we always get the native handle from a UR object, and transferring
+  // ownership from one UR object to another isn't allowed.
+  ASSERT_SUCCESS(urMemImageCreateWithNativeHandle(
+      native_handle, context, &image_format, &image_desc, &props, &mem));
+  ASSERT_NE(nullptr, mem);
+
+  ur_context_handle_t mem_context = nullptr;
+  ASSERT_SUCCESS(urMemGetInfo(mem, UR_MEM_INFO_CONTEXT,
+                              sizeof(ur_context_handle_t), &mem_context,
+                              nullptr));
+  ASSERT_EQ(context, mem_context);
+}
+
 TEST_P(urMemImageCreateWithNativeHandleTest, InvalidNullHandle) {
   ur_native_handle_t native_handle = 0;
   ASSERT_SUCCESS(urMemGetNativeHandle(image, device, &native_handle));

test/conformance/program/urProgramCreateWithNativeHandle.cpp

@@ -47,6 +47,24 @@ TEST_P(urProgramCreateWithNativeHandleTest, Success) {
   ASSERT_NE(ref_count, 0);
 }
 
+TEST_P(urProgramCreateWithNativeHandleTest, SuccessWithProperties) {
+  // We can't pass isNativeHandleOwned = true in the generic tests since
+  // we always get the native handle from a UR object, and transferring
+  // ownership from one UR object to another isn't allowed.
+  ur_program_native_properties_t props = {
+      UR_STRUCTURE_TYPE_PROGRAM_NATIVE_PROPERTIES, nullptr, false};
+  UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(urProgramCreateWithNativeHandle(
+      native_program_handle, context, &props, &native_program));
+
+  uint32_t ref_count = 0;
+
+  ASSERT_SUCCESS(urProgramGetInfo(native_program,
+                                  UR_PROGRAM_INFO_REFERENCE_COUNT,
+                                  sizeof(ref_count), &ref_count, nullptr));
+
+  ASSERT_NE(ref_count, 0);
+}
+
 TEST_P(urProgramCreateWithNativeHandleTest, InvalidNullHandleContext) {
   ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
                    urProgramCreateWithNativeHandle(native_program_handle,

test/conformance/queue/urQueueCreateWithNativeHandle.cpp

@@ -13,13 +13,34 @@ TEST_P(urQueueCreateWithNativeHandleTest, Success) {
 
   UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(
       urQueueGetNativeHandle(queue, nullptr, &native_handle));
+  // We cannot assume anything about a native_handle, not even if it's
+  // `nullptr` since this could be a valid representation within a backend.
+  // We can however convert the native_handle back into a unified-runtime handle
+  // and perform some query on it to verify that it works.
+  ur_queue_handle_t q = nullptr;
+  ASSERT_SUCCESS(urQueueCreateWithNativeHandle(native_handle, context, device,
+                                               nullptr, &q));
+  ASSERT_NE(q, nullptr);
+
+  ur_context_handle_t q_context = nullptr;
+  ASSERT_SUCCESS(urQueueGetInfo(q, UR_QUEUE_INFO_CONTEXT, sizeof(q_context),
+                                &q_context, nullptr));
+  ASSERT_EQ(q_context, context);
+  ASSERT_SUCCESS(urQueueRelease(q));
+}
 
+TEST_P(urQueueCreateWithNativeHandleTest, SuccessWithProperties) {
+  ur_native_handle_t native_handle = 0;
+
+  UUR_ASSERT_SUCCESS_OR_UNSUPPORTED(
+      urQueueGetNativeHandle(queue, nullptr, &native_handle));
   // We cannot assume anything about a native_handle, not even if it's
   // `nullptr` since this could be a valid representation within a backend.
   // We can however convert the native_handle back into a unified-runtime handle
   // and perform some query on it to verify that it works.
   ur_queue_handle_t q = nullptr;
-  ur_queue_native_properties_t properties{};
+  ur_queue_native_properties_t properties = {
+      UR_STRUCTURE_TYPE_QUEUE_NATIVE_PROPERTIES, nullptr, false};
   ASSERT_SUCCESS(urQueueCreateWithNativeHandle(native_handle, context, device,
                                                &properties, &q));
   ASSERT_NE(q, nullptr);