Merge pull request #1394 from omarahmed1111/Add-missing-coverage-in-the-CTS-tests

Add some missing validations in CTS

Author: omarahmed1111

test/conformance/device/urDeviceGet.cpp

@@ -35,6 +35,42 @@ TEST_F(urDeviceGetTest, SuccessSubsetOfDevices) {
     }
 }
 
+struct urDeviceGetTestWithDeviceTypeParam
+    : uur::urAllDevicesTest,
+      ::testing::WithParamInterface<ur_device_type_t> {
+
+    void SetUp() override {
+        UUR_RETURN_ON_FATAL_FAILURE(uur::urAllDevicesTest::SetUp());
+    }
+};
+
+INSTANTIATE_TEST_SUITE_P(
+    , urDeviceGetTestWithDeviceTypeParam,
+    ::testing::Values(UR_DEVICE_TYPE_DEFAULT, UR_DEVICE_TYPE_GPU,
+                      UR_DEVICE_TYPE_CPU, UR_DEVICE_TYPE_FPGA,
+                      UR_DEVICE_TYPE_MCA, UR_DEVICE_TYPE_VPU),
+    [](const ::testing::TestParamInfo<ur_device_type_t> &info) {
+        std::stringstream ss;
+        ss << info.param;
+        return ss.str();
+    });
+
+TEST_P(urDeviceGetTestWithDeviceTypeParam, Success) {
+    ur_device_type_t device_type = GetParam();
+    uint32_t count = 0;
+    ASSERT_SUCCESS(urDeviceGet(platform, device_type, 0, nullptr, &count));
+    ASSERT_GE(devices.size(), count);
+
+    if (count > 0) {
+        std::vector<ur_device_handle_t> devices(count);
+        ASSERT_SUCCESS(
+            urDeviceGet(platform, device_type, count, devices.data(), nullptr));
+        for (auto device : devices) {
+            ASSERT_NE(nullptr, device);
+        }
+    }
+}
+
 TEST_F(urDeviceGetTest, InvalidNullHandlePlatform) {
     uint32_t count;
     ASSERT_EQ_RESULT(

test/conformance/enqueue/urEnqueueMemBufferMap.cpp

@@ -21,14 +21,21 @@ TEST_P(urEnqueueMemBufferMapTest, SuccessRead) {
     }
 }
 
-TEST_P(urEnqueueMemBufferMapTest, SuccessWrite) {
+using urEnqueueMemBufferMapTestWithWriteFlagParam =
+    uur::urMemBufferQueueTestWithParam<ur_map_flag_t>;
+UUR_TEST_SUITE_P(urEnqueueMemBufferMapTestWithWriteFlagParam,
+                 ::testing::Values(UR_MAP_FLAG_WRITE,
+                                   UR_MAP_FLAG_WRITE_INVALIDATE_REGION),
+                 uur::deviceTestWithParamPrinter<ur_map_flag_t>);
+
+TEST_P(urEnqueueMemBufferMapTestWithWriteFlagParam, SuccessWrite) {
     const std::vector<uint32_t> input(count, 0);
     ASSERT_SUCCESS(urEnqueueMemBufferWrite(queue, buffer, true, 0, size,
                                            input.data(), 0, nullptr, nullptr));
 
     uint32_t *map = nullptr;
-    ASSERT_SUCCESS(urEnqueueMemBufferMap(queue, buffer, true, UR_MAP_FLAG_WRITE,
-                                         0, size, 0, nullptr, nullptr,
+    ASSERT_SUCCESS(urEnqueueMemBufferMap(queue, buffer, true, getParam(), 0,
+                                         size, 0, nullptr, nullptr,
                                          (void **)&map));
     for (unsigned i = 0; i < count; ++i) {
         map[i] = 42;

test/conformance/memory/urMemBufferCreate.cpp

@@ -48,6 +48,18 @@ UUR_TEST_SUITE_P(urMemBufferCreateWithHostPtrFlagsTest,
                                    UR_MEM_FLAG_USE_HOST_POINTER),
                  uur::deviceTestWithParamPrinter<ur_mem_flag_t>);
 
+TEST_P(urMemBufferCreateWithHostPtrFlagsTest, SUCCESS) {
+    uur::raii::Mem host_ptr_buffer = nullptr;
+    ASSERT_SUCCESS(urMemBufferCreate(context, UR_MEM_FLAG_ALLOC_HOST_POINTER,
+                                     4096, nullptr, host_ptr_buffer.ptr()));
+
+    ur_buffer_properties_t properties{UR_STRUCTURE_TYPE_BUFFER_PROPERTIES,
+                                      nullptr, host_ptr_buffer.ptr()};
+    uur::raii::Mem buffer = nullptr;
+    ASSERT_SUCCESS(urMemBufferCreate(context, getParam(), 4096, &properties,
+                                     buffer.ptr()));
+}
+
 TEST_P(urMemBufferCreateWithHostPtrFlagsTest, InvalidHostPtr) {
     uur::raii::Mem buffer = nullptr;
     ASSERT_EQ_RESULT(

test/conformance/platform/urPlatformGetInfo.cpp

@@ -19,7 +19,7 @@ INSTANTIATE_TEST_SUITE_P(
     urPlatformGetInfo, urPlatformGetInfoTest,
     ::testing::Values(UR_PLATFORM_INFO_NAME, UR_PLATFORM_INFO_VENDOR_NAME,
                       UR_PLATFORM_INFO_VERSION, UR_PLATFORM_INFO_EXTENSIONS,
-                      UR_PLATFORM_INFO_PROFILE),
+                      UR_PLATFORM_INFO_PROFILE, UR_PLATFORM_INFO_BACKEND),
     [](const ::testing::TestParamInfo<ur_platform_info_t> &info) {
         std::stringstream ss;
         ss << info.param;
@@ -30,11 +30,17 @@ TEST_P(urPlatformGetInfoTest, Success) {
     size_t size = 0;
     ur_platform_info_t info_type = GetParam();
     ASSERT_SUCCESS(urPlatformGetInfo(platform, info_type, 0, nullptr, &size));
-    ASSERT_NE(size, 0);
+    if (info_type == UR_PLATFORM_INFO_BACKEND) {
+        ASSERT_EQ(size, sizeof(ur_platform_backend_t));
+    } else {
+        ASSERT_NE(size, 0);
+    }
     std::vector<char> name(size);
     ASSERT_SUCCESS(
         urPlatformGetInfo(platform, info_type, size, name.data(), nullptr));
-    ASSERT_EQ(size, std::strlen(name.data()) + 1);
+    if (info_type != UR_PLATFORM_INFO_BACKEND) {
+        ASSERT_EQ(size, std::strlen(name.data()) + 1);
+    }
 }
 
 TEST_P(urPlatformGetInfoTest, InvalidNullHandlePlatform) {

test/conformance/program/urProgramBuild.cpp

@@ -12,6 +12,11 @@ TEST_P(urProgramBuildTest, Success) {
     ASSERT_SUCCESS(urProgramBuild(context, program, nullptr));
 }
 
+TEST_P(urProgramBuildTest, SuccessWithOptions) {
+    const char *pOptions = "";
+    ASSERT_SUCCESS(urProgramBuild(context, program, pOptions));
+}
+
 TEST_P(urProgramBuildTest, InvalidNullHandleContext) {
     ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,
                      urProgramBuild(nullptr, program, nullptr));

test/conformance/program/urProgramCreateWithIL.cpp

@@ -36,6 +36,15 @@ TEST_P(urProgramCreateWithILTest, Success) {
     ASSERT_SUCCESS(urProgramRelease(program));
 }
 
+TEST_P(urProgramCreateWithILTest, SuccessWithProperties) {
+    ur_program_properties_t properties{UR_STRUCTURE_TYPE_PROGRAM_PROPERTIES};
+    ur_program_handle_t program = nullptr;
+    ASSERT_SUCCESS(urProgramCreateWithIL(
+        context, il_binary->data(), il_binary->size(), &properties, &program));
+    ASSERT_NE(nullptr, program);
+    ASSERT_SUCCESS(urProgramRelease(program));
+}
+
 TEST_P(urProgramCreateWithILTest, InvalidNullHandle) {
     ur_program_handle_t program = nullptr;
     ASSERT_EQ_RESULT(UR_RESULT_ERROR_INVALID_NULL_HANDLE,

test/conformance/queue/queue_adapter_native_cpu.match

@@ -1,5 +1,14 @@
 urQueueCreateWithParamTest.SuccessWithProperties/SYCL_NATIVE_CPU___SYCL_Native_CPU___UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE
 urQueueCreateWithParamTest.SuccessWithProperties/SYCL_NATIVE_CPU___SYCL_Native_CPU___UR_QUEUE_FLAG_PROFILING_ENABLE
+urQueueCreateWithParamTest.SuccessWithProperties/SYCL_NATIVE_CPU___SYCL_Native_CPU___UR_QUEUE_FLAG_ON_DEVICE
+urQueueCreateWithParamTest.SuccessWithProperties/SYCL_NATIVE_CPU___SYCL_Native_CPU___UR_QUEUE_FLAG_ON_DEVICE_DEFAULT
+urQueueCreateWithParamTest.SuccessWithProperties/SYCL_NATIVE_CPU___SYCL_Native_CPU___UR_QUEUE_FLAG_DISCARD_EVENTS
+urQueueCreateWithParamTest.SuccessWithProperties/SYCL_NATIVE_CPU___SYCL_Native_CPU___UR_QUEUE_FLAG_PRIORITY_LOW
+urQueueCreateWithParamTest.SuccessWithProperties/SYCL_NATIVE_CPU___SYCL_Native_CPU___UR_QUEUE_FLAG_PRIORITY_HIGH
+urQueueCreateWithParamTest.SuccessWithProperties/SYCL_NATIVE_CPU___SYCL_Native_CPU___UR_QUEUE_FLAG_SUBMISSION_BATCHED
+urQueueCreateWithParamTest.SuccessWithProperties/SYCL_NATIVE_CPU___SYCL_Native_CPU___UR_QUEUE_FLAG_SUBMISSION_IMMEDIATE
+urQueueCreateWithParamTest.SuccessWithProperties/SYCL_NATIVE_CPU___SYCL_Native_CPU___UR_QUEUE_FLAG_USE_DEFAULT_STREAM
+urQueueCreateWithParamTest.SuccessWithProperties/SYCL_NATIVE_CPU___SYCL_Native_CPU___UR_QUEUE_FLAG_SYNC_WITH_DEFAULT_STREAM
 urQueueFinishTest.Success/SYCL_NATIVE_CPU___SYCL_Native_CPU_
 urQueueFlushTest.Success/SYCL_NATIVE_CPU___SYCL_Native_CPU_
 urQueueGetInfoTestWithInfoParam.Success/SYCL_NATIVE_CPU___SYCL_Native_CPU___UR_QUEUE_INFO_CONTEXT

test/conformance/queue/urQueueCreate.cpp

@@ -17,7 +17,16 @@ TEST_P(urQueueCreateTest, Success) {
 using urQueueCreateWithParamTest = uur::urContextTestWithParam<ur_queue_flag_t>;
 UUR_TEST_SUITE_P(urQueueCreateWithParamTest,
                  testing::Values(UR_QUEUE_FLAG_OUT_OF_ORDER_EXEC_MODE_ENABLE,
-                                 UR_QUEUE_FLAG_PROFILING_ENABLE),
+                                 UR_QUEUE_FLAG_PROFILING_ENABLE,
+                                 UR_QUEUE_FLAG_ON_DEVICE,
+                                 UR_QUEUE_FLAG_ON_DEVICE_DEFAULT,
+                                 UR_QUEUE_FLAG_DISCARD_EVENTS,
+                                 UR_QUEUE_FLAG_PRIORITY_LOW,
+                                 UR_QUEUE_FLAG_PRIORITY_HIGH,
+                                 UR_QUEUE_FLAG_SUBMISSION_BATCHED,
+                                 UR_QUEUE_FLAG_SUBMISSION_IMMEDIATE,
+                                 UR_QUEUE_FLAG_USE_DEFAULT_STREAM,
+                                 UR_QUEUE_FLAG_SYNC_WITH_DEFAULT_STREAM),
                  uur::deviceTestWithParamPrinter<ur_queue_flag_t>);
 
 TEST_P(urQueueCreateWithParamTest, SuccessWithProperties) {

test/conformance/testing/include/uur/fixtures.h

@@ -526,6 +526,26 @@ struct urMemBufferQueueTest : urQueueTest {
     ur_mem_handle_t buffer = nullptr;
 };
 
+template <class T>
+struct urMemBufferQueueTestWithParam : urQueueTestWithParam<T> {
+    void SetUp() override {
+        UUR_RETURN_ON_FATAL_FAILURE(uur::urQueueTestWithParam<T>::SetUp());
+        ASSERT_SUCCESS(urMemBufferCreate(this->context, UR_MEM_FLAG_READ_WRITE,
+                                         size, nullptr, &buffer));
+    }
+
+    void TearDown() override {
+        if (buffer) {
+            EXPECT_SUCCESS(urMemRelease(buffer));
+        }
+        UUR_RETURN_ON_FATAL_FAILURE(uur::urQueueTestWithParam<T>::TearDown());
+    }
+
+    const size_t count = 8;
+    const size_t size = sizeof(uint32_t) * count;
+    ur_mem_handle_t buffer = nullptr;
+};
+
 struct urMemImageQueueTest : urQueueTest {
     void SetUp() override {
         UUR_RETURN_ON_FATAL_FAILURE(urQueueTest::SetUp());