diff --git a/conformance_tests/core/test_copy/src/test_copy.cpp b/conformance_tests/core/test_copy/src/test_copy.cpp
index 221d2668..14f98fa1 100644
--- a/conformance_tests/core/test_copy/src/test_copy.cpp
+++ b/conformance_tests/core/test_copy/src/test_copy.cpp
@@ -29,29 +29,6 @@ using lzt::to_int;
 using lzt::to_u32;
 using lzt::to_u8;
 
-void get_copy_and_compute_ordinals(
-    const std::vector<ze_command_queue_group_properties_t>
-        &cmd_queue_group_props,
-    int &compute_ordinal, int &copy_ordinal) {
-  for (uint32_t i = 0; i < cmd_queue_group_props.size(); i++) {
-    if (cmd_queue_group_props[i].flags &
-            ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE &&
-        compute_ordinal < 0) {
-      compute_ordinal = to_int(i);
-    }
-    if (cmd_queue_group_props[i].flags &
-            ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY &&
-        !(cmd_queue_group_props[i].flags &
-          ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE) &&
-        copy_ordinal < 0) {
-      copy_ordinal = to_int(i);
-    }
-    if (compute_ordinal >= 0 && copy_ordinal >= 0) {
-      break;
-    }
-  }
-}
-
 class zeCommandListAppendMemoryFillTests : public ::testing::Test {
 protected:
   void RunMaxMemoryFillTest(bool is_immediate, bool is_shared_system);
@@ -69,15 +46,20 @@ void zeCommandListAppendMemoryFillTests::
   auto cmd_queue_group_props = get_command_queue_group_properties(
       zeDevice::get_instance()->get_device());
 
-  int compute_ordinal = -1, copy_ordinal = -1;
-  get_copy_and_compute_ordinals(cmd_queue_group_props, compute_ordinal,
-                                copy_ordinal);
-  ASSERT_TRUE((use_copy_engine && copy_ordinal >= 0) ||
-              (!use_copy_engine && compute_ordinal >= 0));
+  auto compute_ordinal = lzt::get_queue_ordinal(
+      cmd_queue_group_props,
+      ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE |
+          ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COOPERATIVE_KERNELS,
+      0);
+  auto copy_ordinal = lzt::get_queue_ordinal(
+      cmd_queue_group_props, ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY,
+      ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE);
+  ASSERT_TRUE((use_copy_engine && copy_ordinal) ||
+              (!use_copy_engine && compute_ordinal));
 
   auto cmd_bundle = lzt::create_command_bundle(
       lzt::get_default_context(), zeDevice::get_instance()->get_device(), 0,
-      to_u32(use_copy_engine ? copy_ordinal : compute_ordinal), is_immediate);
+      use_copy_engine ? *copy_ordinal : *compute_ordinal, is_immediate);
   const size_t size = 4096;
   void *memory = lzt::allocate_device_memory_with_allocator_selector(
       size, is_shared_system);
@@ -212,15 +194,20 @@ void zeCommandListAppendMemoryFillTests::
   auto cmd_queue_group_props = get_command_queue_group_properties(
       zeDevice::get_instance()->get_device());
 
-  int compute_ordinal = -1, copy_ordinal = -1;
-  get_copy_and_compute_ordinals(cmd_queue_group_props, compute_ordinal,
-                                copy_ordinal);
-  ASSERT_TRUE((use_copy_engine && copy_ordinal >= 0) ||
-              (!use_copy_engine && compute_ordinal >= 0));
+  auto compute_ordinal = lzt::get_queue_ordinal(
+      cmd_queue_group_props,
+      ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE |
+          ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COOPERATIVE_KERNELS,
+      0);
+  auto copy_ordinal = lzt::get_queue_ordinal(
+      cmd_queue_group_props, ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY,
+      ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE);
+  ASSERT_TRUE((use_copy_engine && copy_ordinal) ||
+              (!use_copy_engine && compute_ordinal));
 
   auto cmd_bundle = lzt::create_command_bundle(
       lzt::get_default_context(), zeDevice::get_instance()->get_device(), 0,
-      to_u32(use_copy_engine ? copy_ordinal : compute_ordinal), is_immediate);
+      use_copy_engine ? *copy_ordinal : *compute_ordinal, is_immediate);
   const size_t size = 4096;
   void *memory = lzt::allocate_device_memory_with_allocator_selector(
       size, is_shared_system);
@@ -307,15 +294,20 @@ void zeCommandListAppendMemoryFillTests::
   auto cmd_queue_group_props = get_command_queue_group_properties(
       zeDevice::get_instance()->get_device());
 
-  int compute_ordinal = -1, copy_ordinal = -1;
-  get_copy_and_compute_ordinals(cmd_queue_group_props, compute_ordinal,
-                                copy_ordinal);
-  ASSERT_TRUE((use_copy_engine && copy_ordinal >= 0) ||
-              (!use_copy_engine && compute_ordinal >= 0));
+  auto compute_ordinal = lzt::get_queue_ordinal(
+      cmd_queue_group_props,
+      ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE |
+          ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COOPERATIVE_KERNELS,
+      0);
+  auto copy_ordinal = lzt::get_queue_ordinal(
+      cmd_queue_group_props, ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY,
+      ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE);
+  ASSERT_TRUE((use_copy_engine && copy_ordinal) ||
+              (!use_copy_engine && compute_ordinal));
 
   auto cmd_bundle = lzt::create_command_bundle(
       lzt::get_default_context(), zeDevice::get_instance()->get_device(), 0,
-      to_u32(use_copy_engine ? copy_ordinal : compute_ordinal), is_immediate);
+      use_copy_engine ? *copy_ordinal : *compute_ordinal, is_immediate);
   const size_t size = 4096;
   void *memory = lzt::allocate_device_memory_with_allocator_selector(
       size, is_shared_system);
@@ -1367,15 +1359,20 @@ void zeCommandListAppendMemoryCopyTests::
   auto cmd_queue_group_props = get_command_queue_group_properties(
       zeDevice::get_instance()->get_device());
 
-  int compute_ordinal = -1, copy_ordinal = -1;
-  get_copy_and_compute_ordinals(cmd_queue_group_props, compute_ordinal,
-                                copy_ordinal);
-  ASSERT_TRUE((use_copy_engine && copy_ordinal >= 0) ||
-              (!use_copy_engine && compute_ordinal >= 0));
+  auto compute_ordinal = lzt::get_queue_ordinal(
+      cmd_queue_group_props,
+      ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE |
+          ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COOPERATIVE_KERNELS,
+      0);
+  auto copy_ordinal = lzt::get_queue_ordinal(
+      cmd_queue_group_props, ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY,
+      ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE);
+  ASSERT_TRUE((use_copy_engine && copy_ordinal) ||
+              (!use_copy_engine && compute_ordinal));
 
   auto cmd_bundle = lzt::create_command_bundle(
       lzt::get_default_context(), zeDevice::get_instance()->get_device(), 0,
-      to_u32(use_copy_engine ? copy_ordinal : compute_ordinal), is_immediate);
+      use_copy_engine ? *copy_ordinal : *compute_ordinal, is_immediate);
 
   const size_t size = 16;
   const std::vector<char> host_memory(size, 123);
@@ -1449,15 +1446,20 @@ void zeCommandListAppendMemoryCopyTests::
   auto cmd_queue_group_props = get_command_queue_group_properties(
       zeDevice::get_instance()->get_device());
 
-  int compute_ordinal = -1, copy_ordinal = -1;
-  get_copy_and_compute_ordinals(cmd_queue_group_props, compute_ordinal,
-                                copy_ordinal);
-  ASSERT_TRUE((use_copy_engine && copy_ordinal >= 0) ||
-              (!use_copy_engine && compute_ordinal >= 0));
+  auto compute_ordinal = lzt::get_queue_ordinal(
+      cmd_queue_group_props,
+      ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE |
+          ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COOPERATIVE_KERNELS,
+      0);
+  auto copy_ordinal = lzt::get_queue_ordinal(
+      cmd_queue_group_props, ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY,
+      ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE);
+  ASSERT_TRUE((use_copy_engine && copy_ordinal) ||
+              (!use_copy_engine && compute_ordinal));
 
   auto cmd_bundle = lzt::create_command_bundle(
       lzt::get_default_context(), zeDevice::get_instance()->get_device(), 0,
-      to_u32(use_copy_engine ? copy_ordinal : compute_ordinal), is_immediate);
+      use_copy_engine ? *copy_ordinal : *compute_ordinal, is_immediate);
 
   lzt::zeEventPool ep;
   const size_t size = 16;
@@ -1543,15 +1545,20 @@ void zeCommandListAppendMemoryCopyTests::
   auto cmd_queue_group_props = get_command_queue_group_properties(
       zeDevice::get_instance()->get_device());
 
-  int compute_ordinal = -1, copy_ordinal = -1;
-  get_copy_and_compute_ordinals(cmd_queue_group_props, compute_ordinal,
-                                copy_ordinal);
-  ASSERT_TRUE((use_copy_engine && copy_ordinal >= 0) ||
-              (!use_copy_engine && compute_ordinal >= 0));
+  auto compute_ordinal = lzt::get_queue_ordinal(
+      cmd_queue_group_props,
+      ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE |
+          ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COOPERATIVE_KERNELS,
+      0);
+  auto copy_ordinal = lzt::get_queue_ordinal(
+      cmd_queue_group_props, ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY,
+      ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE);
+  ASSERT_TRUE((use_copy_engine && copy_ordinal) ||
+              (!use_copy_engine && compute_ordinal));
 
   auto cmd_bundle = lzt::create_command_bundle(
       lzt::get_default_context(), zeDevice::get_instance()->get_device(), 0,
-      to_u32(use_copy_engine ? copy_ordinal : compute_ordinal), is_immediate);
+      use_copy_engine ? *copy_ordinal : *compute_ordinal, is_immediate);
 
   lzt::zeEventPool ep;
   const size_t size = 16;
diff --git a/conformance_tests/core/test_copy/src/test_copy_image.cpp b/conformance_tests/core/test_copy/src/test_copy_image.cpp
index 765f5e1a..17203e20 100644
--- a/conformance_tests/core/test_copy/src/test_copy_image.cpp
+++ b/conformance_tests/core/test_copy/src/test_copy_image.cpp
@@ -211,8 +211,24 @@ class zeCommandListAppendImageCopyTests : public ::testing::Test {
   }
 
   void test_image_mem_copy_no_regions(void *source_buff, void *dest_buff,
-                                      bool is_immediate) {
-    auto cmd_bundle = lzt::create_command_bundle(is_immediate);
+                                      bool is_immediate, bool use_copy_engine) {
+    auto cmd_queue_group_props = get_command_queue_group_properties(
+        zeDevice::get_instance()->get_device());
+
+    auto compute_ordinal = lzt::get_queue_ordinal(
+        cmd_queue_group_props,
+        ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE |
+            ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COOPERATIVE_KERNELS,
+        0);
+    auto copy_ordinal = lzt::get_queue_ordinal(
+        cmd_queue_group_props, ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY,
+        ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE);
+    ASSERT_TRUE((use_copy_engine && copy_ordinal) ||
+                (!use_copy_engine && compute_ordinal));
+
+    auto cmd_bundle = lzt::create_command_bundle(
+        lzt::get_default_context(), zeDevice::get_instance()->get_device(), 0,
+        use_copy_engine ? *copy_ordinal : *compute_ordinal, is_immediate);
 
     // Copies proceeds as follows:
     // png -> source_buff -> image -> dest_buff ->png
@@ -240,8 +256,25 @@ class zeCommandListAppendImageCopyTests : public ::testing::Test {
   void test_image_mem_copy_use_regions(void *source_buff_bot,
                                        void *source_buff_top,
                                        void *dest_buff_bot, void *dest_buff_top,
-                                       bool is_immediate) {
-    auto cmd_bundle = lzt::create_command_bundle(is_immediate);
+                                       bool is_immediate,
+                                       bool use_copy_engine) {
+    auto cmd_queue_group_props = get_command_queue_group_properties(
+        zeDevice::get_instance()->get_device());
+
+    auto compute_ordinal = lzt::get_queue_ordinal(
+        cmd_queue_group_props,
+        ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE |
+            ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COOPERATIVE_KERNELS,
+        0);
+    auto copy_ordinal = lzt::get_queue_ordinal(
+        cmd_queue_group_props, ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COPY,
+        ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COMPUTE);
+    ASSERT_TRUE((use_copy_engine && copy_ordinal) ||
+                (!use_copy_engine && compute_ordinal));
+
+    auto cmd_bundle = lzt::create_command_bundle(
+        lzt::get_default_context(), zeDevice::get_instance()->get_device(), 0,
+        use_copy_engine ? *copy_ordinal : *compute_ordinal, is_immediate);
 
     ze_image_region_t bot_region = {0, 0, 0, image_width, image_height / 2, 1};
     ze_image_region_t top_region = {0,           image_height / 2, 0,
@@ -509,7 +542,7 @@ LZT_TEST_F(
   void *buff_in_bot = lzt::allocate_host_memory(image_size);
   void *buff_out_top = lzt::allocate_host_memory(image_size);
   test_image_mem_copy_use_regions(buff_in_bot, buff_in_top, buff_out_bot,
-                                  buff_out_top, false);
+                                  buff_out_top, false, false);
   lzt::free_memory(buff_in_bot);
   lzt::free_memory(buff_in_top);
   lzt::free_memory(buff_out_bot);
@@ -527,7 +560,43 @@ LZT_TEST_F(
   void *buff_in_bot = lzt::allocate_host_memory(image_size);
   void *buff_out_top = lzt::allocate_host_memory(image_size);
   test_image_mem_copy_use_regions(buff_in_bot, buff_in_top, buff_out_bot,
-                                  buff_out_top, true);
+                                  buff_out_top, true, false);
+  lzt::free_memory(buff_in_bot);
+  lzt::free_memory(buff_in_top);
+  lzt::free_memory(buff_out_bot);
+  lzt::free_memory(buff_out_top);
+}
+
+LZT_TEST_F(
+    zeCommandListAppendImageCopyTests,
+    GivenDeviceImageAndHostImageWhenAppendingImageCopyFromMemoryUsingCopyEngineAndHostMemoryWithNonNullRegionsThenImageIsCorrectAndSuccessIsReturned) {
+  if (!(lzt::image_support())) {
+    GTEST_SKIP();
+  }
+  void *buff_in_top = lzt::allocate_host_memory(image_size);
+  void *buff_out_bot = lzt::allocate_host_memory(image_size);
+  void *buff_in_bot = lzt::allocate_host_memory(image_size);
+  void *buff_out_top = lzt::allocate_host_memory(image_size);
+  test_image_mem_copy_use_regions(buff_in_bot, buff_in_top, buff_out_bot,
+                                  buff_out_top, false, true);
+  lzt::free_memory(buff_in_bot);
+  lzt::free_memory(buff_in_top);
+  lzt::free_memory(buff_out_bot);
+  lzt::free_memory(buff_out_top);
+}
+
+LZT_TEST_F(
+    zeCommandListAppendImageCopyTests,
+    GivenDeviceImageAndHostImageWhenAppendingImageCopyFromMemoryToImmediateCmdListUsingCopyEngineAndHostMemoryWithNonNullRegionsThenImageIsCorrectAndSuccessIsReturned) {
+  if (!(lzt::image_support())) {
+    GTEST_SKIP();
+  }
+  void *buff_in_top = lzt::allocate_host_memory(image_size);
+  void *buff_out_bot = lzt::allocate_host_memory(image_size);
+  void *buff_in_bot = lzt::allocate_host_memory(image_size);
+  void *buff_out_top = lzt::allocate_host_memory(image_size);
+  test_image_mem_copy_use_regions(buff_in_bot, buff_in_top, buff_out_bot,
+                                  buff_out_top, true, true);
   lzt::free_memory(buff_in_bot);
   lzt::free_memory(buff_in_top);
   lzt::free_memory(buff_out_bot);
@@ -542,7 +611,7 @@ LZT_TEST_F(
   }
   void *buff_in = lzt::allocate_host_memory(image_size);
   void *buff_out = lzt::allocate_host_memory(image_size);
-  test_image_mem_copy_no_regions(buff_in, buff_out, false);
+  test_image_mem_copy_no_regions(buff_in, buff_out, false, false);
   lzt::free_memory(buff_in);
   lzt::free_memory(buff_out);
 }
@@ -555,7 +624,33 @@ LZT_TEST_F(
   }
   void *buff_in = lzt::allocate_host_memory(image_size);
   void *buff_out = lzt::allocate_host_memory(image_size);
-  test_image_mem_copy_no_regions(buff_in, buff_out, true);
+  test_image_mem_copy_no_regions(buff_in, buff_out, true, false);
+  lzt::free_memory(buff_in);
+  lzt::free_memory(buff_out);
+}
+
+LZT_TEST_F(
+    zeCommandListAppendImageCopyTests,
+    GivenDeviceImageAndHostImageWhenAppendingImageCopyFromMemoryUsingCopyEngineAndHostMemoryWithNullRegionsThenImageIsCorrectAndSuccessIsReturned) {
+  if (!(lzt::image_support())) {
+    GTEST_SKIP();
+  }
+  void *buff_in = lzt::allocate_host_memory(image_size);
+  void *buff_out = lzt::allocate_host_memory(image_size);
+  test_image_mem_copy_no_regions(buff_in, buff_out, false, true);
+  lzt::free_memory(buff_in);
+  lzt::free_memory(buff_out);
+}
+
+LZT_TEST_F(
+    zeCommandListAppendImageCopyTests,
+    GivenDeviceImageAndHostImageWhenAppendingImageCopyToImmediateCmdListFromMemoryUsingCopyEngineAndHostMemoryWithNullRegionsThenImageIsCorrectAndSuccessIsReturned) {
+  if (!(lzt::image_support())) {
+    GTEST_SKIP();
+  }
+  void *buff_in = lzt::allocate_host_memory(image_size);
+  void *buff_out = lzt::allocate_host_memory(image_size);
+  test_image_mem_copy_no_regions(buff_in, buff_out, true, true);
   lzt::free_memory(buff_in);
   lzt::free_memory(buff_out);
 }
@@ -571,7 +666,7 @@ LZT_TEST_F(
   void *buff_in_bot = lzt::allocate_device_memory(image_size);
   void *buff_out_top = lzt::allocate_device_memory(image_size);
   test_image_mem_copy_use_regions(buff_in_bot, buff_in_top, buff_out_bot,
-                                  buff_out_top, false);
+                                  buff_out_top, false, false);
   lzt::free_memory(buff_in_bot);
   lzt::free_memory(buff_in_top);
   lzt::free_memory(buff_out_bot);
@@ -589,7 +684,43 @@ LZT_TEST_F(
   void *buff_in_bot = lzt::allocate_device_memory(image_size);
   void *buff_out_top = lzt::allocate_device_memory(image_size);
   test_image_mem_copy_use_regions(buff_in_bot, buff_in_top, buff_out_bot,
-                                  buff_out_top, true);
+                                  buff_out_top, true, false);
+  lzt::free_memory(buff_in_bot);
+  lzt::free_memory(buff_in_top);
+  lzt::free_memory(buff_out_bot);
+  lzt::free_memory(buff_out_top);
+}
+
+LZT_TEST_F(
+    zeCommandListAppendImageCopyTests,
+    GivenDeviceImageAndHostImageWhenAppendingImageCopyFromMemoryUsingCopyEngineAndDeviceMemoryWithNonNullRegionsThenImageIsCorrectAndSuccessIsReturned) {
+  if (!(lzt::image_support())) {
+    GTEST_SKIP();
+  }
+  void *buff_in_top = lzt::allocate_device_memory(image_size);
+  void *buff_out_bot = lzt::allocate_device_memory(image_size);
+  void *buff_in_bot = lzt::allocate_device_memory(image_size);
+  void *buff_out_top = lzt::allocate_device_memory(image_size);
+  test_image_mem_copy_use_regions(buff_in_bot, buff_in_top, buff_out_bot,
+                                  buff_out_top, false, true);
+  lzt::free_memory(buff_in_bot);
+  lzt::free_memory(buff_in_top);
+  lzt::free_memory(buff_out_bot);
+  lzt::free_memory(buff_out_top);
+}
+
+LZT_TEST_F(
+    zeCommandListAppendImageCopyTests,
+    GivenDeviceImageAndHostImageWhenAppendingImageCopyFromMemoryToImmediateCmdListUsingCopyEngineAndDeviceMemoryWithNonNullRegionsThenImageIsCorrectAndSuccessIsReturned) {
+  if (!(lzt::image_support())) {
+    GTEST_SKIP();
+  }
+  void *buff_in_top = lzt::allocate_device_memory(image_size);
+  void *buff_out_bot = lzt::allocate_device_memory(image_size);
+  void *buff_in_bot = lzt::allocate_device_memory(image_size);
+  void *buff_out_top = lzt::allocate_device_memory(image_size);
+  test_image_mem_copy_use_regions(buff_in_bot, buff_in_top, buff_out_bot,
+                                  buff_out_top, true, true);
   lzt::free_memory(buff_in_bot);
   lzt::free_memory(buff_in_top);
   lzt::free_memory(buff_out_bot);
@@ -604,7 +735,7 @@ LZT_TEST_F(
   }
   void *buff_in = lzt::allocate_device_memory(image_size);
   void *buff_out = lzt::allocate_device_memory(image_size);
-  test_image_mem_copy_no_regions(buff_in, buff_out, false);
+  test_image_mem_copy_no_regions(buff_in, buff_out, false, false);
   lzt::free_memory(buff_in);
   lzt::free_memory(buff_out);
 }
@@ -617,7 +748,33 @@ LZT_TEST_F(
   }
   void *buff_in = lzt::allocate_device_memory(image_size);
   void *buff_out = lzt::allocate_device_memory(image_size);
-  test_image_mem_copy_no_regions(buff_in, buff_out, true);
+  test_image_mem_copy_no_regions(buff_in, buff_out, true, false);
+  lzt::free_memory(buff_in);
+  lzt::free_memory(buff_out);
+}
+
+LZT_TEST_F(
+    zeCommandListAppendImageCopyTests,
+    GivenDeviceImageAndHostImageWhenAppendingImageCopyFromMemoryUsingCopyEngineAndDeviceMemoryWithNullRegionsThenImageIsCorrectAndSuccessIsReturned) {
+  if (!(lzt::image_support())) {
+    GTEST_SKIP();
+  }
+  void *buff_in = lzt::allocate_device_memory(image_size);
+  void *buff_out = lzt::allocate_device_memory(image_size);
+  test_image_mem_copy_no_regions(buff_in, buff_out, false, true);
+  lzt::free_memory(buff_in);
+  lzt::free_memory(buff_out);
+}
+
+LZT_TEST_F(
+    zeCommandListAppendImageCopyTests,
+    GivenDeviceImageAndHostImageWhenAppendingImageCopyFromMemoryToImmediateCmdListUsingCopyEngineAndDeviceMemoryWithNullRegionsThenImageIsCorrectAndSuccessIsReturned) {
+  if (!(lzt::image_support())) {
+    GTEST_SKIP();
+  }
+  void *buff_in = lzt::allocate_device_memory(image_size);
+  void *buff_out = lzt::allocate_device_memory(image_size);
+  test_image_mem_copy_no_regions(buff_in, buff_out, true, true);
   lzt::free_memory(buff_in);
   lzt::free_memory(buff_out);
 }
@@ -633,7 +790,7 @@ LZT_TEST_F(
   void *buff_in_bot = lzt::allocate_shared_memory(image_size);
   void *buff_out_top = lzt::allocate_shared_memory(image_size);
   test_image_mem_copy_use_regions(buff_in_bot, buff_in_top, buff_out_bot,
-                                  buff_out_top, false);
+                                  buff_out_top, false, false);
   lzt::free_memory(buff_in_bot);
   lzt::free_memory(buff_in_top);
   lzt::free_memory(buff_out_bot);
@@ -651,7 +808,43 @@ LZT_TEST_F(
   void *buff_in_bot = lzt::allocate_shared_memory(image_size);
   void *buff_out_top = lzt::allocate_shared_memory(image_size);
   test_image_mem_copy_use_regions(buff_in_bot, buff_in_top, buff_out_bot,
-                                  buff_out_top, true);
+                                  buff_out_top, true, false);
+  lzt::free_memory(buff_in_bot);
+  lzt::free_memory(buff_in_top);
+  lzt::free_memory(buff_out_bot);
+  lzt::free_memory(buff_out_top);
+}
+
+LZT_TEST_F(
+    zeCommandListAppendImageCopyTests,
+    GivenDeviceImageAndHostImageWhenAppendingImageCopyFromMemoryUsingCopyEngineAndSharedMemoryWithNonNullRegionsThenImageIsCorrectAndSuccessIsReturned) {
+  if (!(lzt::image_support())) {
+    GTEST_SKIP();
+  }
+  void *buff_in_top = lzt::allocate_shared_memory(image_size);
+  void *buff_out_bot = lzt::allocate_shared_memory(image_size);
+  void *buff_in_bot = lzt::allocate_shared_memory(image_size);
+  void *buff_out_top = lzt::allocate_shared_memory(image_size);
+  test_image_mem_copy_use_regions(buff_in_bot, buff_in_top, buff_out_bot,
+                                  buff_out_top, false, true);
+  lzt::free_memory(buff_in_bot);
+  lzt::free_memory(buff_in_top);
+  lzt::free_memory(buff_out_bot);
+  lzt::free_memory(buff_out_top);
+}
+
+LZT_TEST_F(
+    zeCommandListAppendImageCopyTests,
+    GivenDeviceImageAndHostImageWhenAppendingImageCopyFromMemoryToImmediateCmdListUsingCopyEngineAndSharedMemoryWithNonNullRegionsThenImageIsCorrectAndSuccessIsReturned) {
+  if (!(lzt::image_support())) {
+    GTEST_SKIP();
+  }
+  void *buff_in_top = lzt::allocate_shared_memory(image_size);
+  void *buff_out_bot = lzt::allocate_shared_memory(image_size);
+  void *buff_in_bot = lzt::allocate_shared_memory(image_size);
+  void *buff_out_top = lzt::allocate_shared_memory(image_size);
+  test_image_mem_copy_use_regions(buff_in_bot, buff_in_top, buff_out_bot,
+                                  buff_out_top, true, true);
   lzt::free_memory(buff_in_bot);
   lzt::free_memory(buff_in_top);
   lzt::free_memory(buff_out_bot);
@@ -666,7 +859,7 @@ LZT_TEST_F(
   }
   void *buff_in = lzt::allocate_shared_memory(image_size);
   void *buff_out = lzt::allocate_shared_memory(image_size);
-  test_image_mem_copy_no_regions(buff_in, buff_out, false);
+  test_image_mem_copy_no_regions(buff_in, buff_out, false, false);
   lzt::free_memory(buff_in);
   lzt::free_memory(buff_out);
 }
@@ -679,7 +872,33 @@ LZT_TEST_F(
   }
   void *buff_in = lzt::allocate_shared_memory(image_size);
   void *buff_out = lzt::allocate_shared_memory(image_size);
-  test_image_mem_copy_no_regions(buff_in, buff_out, true);
+  test_image_mem_copy_no_regions(buff_in, buff_out, true, false);
+  lzt::free_memory(buff_in);
+  lzt::free_memory(buff_out);
+}
+
+LZT_TEST_F(
+    zeCommandListAppendImageCopyTests,
+    GivenDeviceImageAndHostImageWhenAppendingImageCopyFromMemoryUsingCopyEngineAndSharedMemoryWithNullRegionsThenImageIsCorrectAndSuccessIsReturned) {
+  if (!(lzt::image_support())) {
+    GTEST_SKIP();
+  }
+  void *buff_in = lzt::allocate_shared_memory(image_size);
+  void *buff_out = lzt::allocate_shared_memory(image_size);
+  test_image_mem_copy_no_regions(buff_in, buff_out, false, true);
+  lzt::free_memory(buff_in);
+  lzt::free_memory(buff_out);
+}
+
+LZT_TEST_F(
+    zeCommandListAppendImageCopyTests,
+    GivenDeviceImageAndHostImageWhenAppendingImageCopyFromMemoryToImmediateCmdListUsingCopyEngineAndSharedMemoryWithNullRegionsThenImageIsCorrectAndSuccessIsReturned) {
+  if (!(lzt::image_support())) {
+    GTEST_SKIP();
+  }
+  void *buff_in = lzt::allocate_shared_memory(image_size);
+  void *buff_out = lzt::allocate_shared_memory(image_size);
+  test_image_mem_copy_no_regions(buff_in, buff_out, true, true);
   lzt::free_memory(buff_in);
   lzt::free_memory(buff_out);
 }
@@ -696,7 +915,26 @@ LZT_TEST_F(
   void *buff_in_bot = lzt::aligned_malloc(image_size, 1);
   void *buff_out_top = lzt::aligned_malloc(image_size, 1);
   test_image_mem_copy_use_regions(buff_in_bot, buff_in_top, buff_out_bot,
-                                  buff_out_top, false);
+                                  buff_out_top, false, false);
+  lzt::aligned_free(buff_in_bot);
+  lzt::aligned_free(buff_in_top);
+  lzt::aligned_free(buff_out_bot);
+  lzt::aligned_free(buff_out_top);
+}
+
+LZT_TEST_F(
+    zeCommandListAppendImageCopyTests,
+    GivenDeviceImageAndHostImageWhenAppendingImageCopyFromMemoryUsingCopyEngineAndSharedSystemMemoryWithNonNullRegionsThenImageIsCorrectAndSuccessIsReturnedWithSharedSystemAllocator) {
+  SKIP_IF_SHARED_SYSTEM_ALLOC_UNSUPPORTED();
+  if (!(lzt::image_support())) {
+    GTEST_SKIP();
+  }
+  void *buff_in_top = lzt::aligned_malloc(image_size, 1);
+  void *buff_out_bot = lzt::aligned_malloc(image_size, 1);
+  void *buff_in_bot = lzt::aligned_malloc(image_size, 1);
+  void *buff_out_top = lzt::aligned_malloc(image_size, 1);
+  test_image_mem_copy_use_regions(buff_in_bot, buff_in_top, buff_out_bot,
+                                  buff_out_top, false, true);
   lzt::aligned_free(buff_in_bot);
   lzt::aligned_free(buff_in_top);
   lzt::aligned_free(buff_out_bot);
@@ -715,7 +953,26 @@ LZT_TEST_F(
   void *buff_in_bot = lzt::aligned_malloc(image_size, 1);
   void *buff_out_top = lzt::aligned_malloc(image_size, 1);
   test_image_mem_copy_use_regions(buff_in_bot, buff_in_top, buff_out_bot,
-                                  buff_out_top, true);
+                                  buff_out_top, true, false);
+  lzt::aligned_free(buff_in_bot);
+  lzt::aligned_free(buff_in_top);
+  lzt::aligned_free(buff_out_bot);
+  lzt::aligned_free(buff_out_top);
+}
+
+LZT_TEST_F(
+    zeCommandListAppendImageCopyTests,
+    GivenDeviceImageAndHostImageWhenAppendingImageCopyFromMemoryToImmediateCmdListUsingCopyEngineAndSharedSystemMemoryWithNonNullRegionsThenImageIsCorrectAndSuccessIsReturnedWithSharedSystemAllocator) {
+  SKIP_IF_SHARED_SYSTEM_ALLOC_UNSUPPORTED();
+  if (!(lzt::image_support())) {
+    GTEST_SKIP();
+  }
+  void *buff_in_top = lzt::aligned_malloc(image_size, 1);
+  void *buff_out_bot = lzt::aligned_malloc(image_size, 1);
+  void *buff_in_bot = lzt::aligned_malloc(image_size, 1);
+  void *buff_out_top = lzt::aligned_malloc(image_size, 1);
+  test_image_mem_copy_use_regions(buff_in_bot, buff_in_top, buff_out_bot,
+                                  buff_out_top, true, true);
   lzt::aligned_free(buff_in_bot);
   lzt::aligned_free(buff_in_top);
   lzt::aligned_free(buff_out_bot);
@@ -731,7 +988,7 @@ LZT_TEST_F(
   }
   void *buff_in = lzt::aligned_malloc(image_size, 1);
   void *buff_out = lzt::aligned_malloc(image_size, 1);
-  test_image_mem_copy_no_regions(buff_in, buff_out, false);
+  test_image_mem_copy_no_regions(buff_in, buff_out, false, false);
   lzt::aligned_free(buff_in);
   lzt::aligned_free(buff_out);
 }
@@ -745,7 +1002,35 @@ LZT_TEST_F(
   }
   void *buff_in = lzt::aligned_malloc(image_size, 1);
   void *buff_out = lzt::aligned_malloc(image_size, 1);
-  test_image_mem_copy_no_regions(buff_in, buff_out, true);
+  test_image_mem_copy_no_regions(buff_in, buff_out, true, false);
+  lzt::aligned_free(buff_in);
+  lzt::aligned_free(buff_out);
+}
+
+LZT_TEST_F(
+    zeCommandListAppendImageCopyTests,
+    GivenDeviceImageAndHostImageWhenAppendingImageCopyFromMemoryUsingCopyEngineAndSharedSystemMemoryWithNullRegionsThenImageIsCorrectAndSuccessIsReturnedWithSharedSystemAllocator) {
+  SKIP_IF_SHARED_SYSTEM_ALLOC_UNSUPPORTED();
+  if (!(lzt::image_support())) {
+    GTEST_SKIP();
+  }
+  void *buff_in = lzt::aligned_malloc(image_size, 1);
+  void *buff_out = lzt::aligned_malloc(image_size, 1);
+  test_image_mem_copy_no_regions(buff_in, buff_out, false, true);
+  lzt::aligned_free(buff_in);
+  lzt::aligned_free(buff_out);
+}
+
+LZT_TEST_F(
+    zeCommandListAppendImageCopyTests,
+    GivenDeviceImageAndHostImageWhenAppendingImageCopyToImmediateCmdListFromMemoryUsingCopyEngineAndSharedSystemMemoryWithNullRegionsThenImageIsCorrectAndSuccessIsReturnedWithSharedSystemAllocator) {
+  SKIP_IF_SHARED_SYSTEM_ALLOC_UNSUPPORTED();
+  if (!(lzt::image_support())) {
+    GTEST_SKIP();
+  }
+  void *buff_in = lzt::aligned_malloc(image_size, 1);
+  void *buff_out = lzt::aligned_malloc(image_size, 1);
+  test_image_mem_copy_no_regions(buff_in, buff_out, true, true);
   lzt::aligned_free(buff_in);
   lzt::aligned_free(buff_out);
 }
diff --git a/conformance_tests/core/test_memory/src/test_svm.cpp b/conformance_tests/core/test_memory/src/test_svm.cpp
index 20fe8455..56da4f82 100644
--- a/conformance_tests/core/test_memory/src/test_svm.cpp
+++ b/conformance_tests/core/test_memory/src/test_svm.cpp
@@ -157,17 +157,12 @@ class SharedSystemMemoryLaunchCooperativeKernelTests
 LZT_TEST_P(
     SharedSystemMemoryLaunchCooperativeKernelTests,
     GivenSharedSystemMemoryAllocationsAsKernelArgumentsWhenCooperativeKernelExecutesThenValueIsCorrect) {
-  int ordinal = -1;
   auto command_queue_group_properties =
       lzt::get_command_queue_group_properties(device);
-  for (int i = 0; i < command_queue_group_properties.size(); i++) {
-    if (command_queue_group_properties[i].flags &
-        ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COOPERATIVE_KERNELS) {
-      ordinal = i;
-      break;
-    }
-  }
-  if (ordinal < 0) {
+  auto ordinal = lzt::get_queue_ordinal(
+      command_queue_group_properties,
+      ZE_COMMAND_QUEUE_GROUP_PROPERTY_FLAG_COOPERATIVE_KERNELS, 0);
+  if (!ordinal) {
     LOG_WARNING << "No command queues that support cooperative kernels";
     GTEST_SKIP();
   }
@@ -209,15 +204,15 @@ LZT_TEST_P(
     return n - (n >> 1);
   }(max_coop_group_count);
 
-  uint32_t group_count = (num_elements < suggested_group_count)
-                             ? num_elements
+  uint32_t group_count = (lzt::to_u32(num_elements) < suggested_group_count)
+                             ? lzt::to_u32(num_elements)
                              : suggested_group_count;
   LOG_INFO << "Group count: " << group_count;
 
   void *output = lzt::allocate_shared_memory_with_allocator_selector(
       group_count * sizeof(int), 1, 0, 0, device, is_dst_shared_system);
 
-  uint32_t group_size = num_elements / group_count;
+  uint32_t group_size = lzt::to_u32(num_elements) / group_count;
   LOG_INFO << "Group size: " << group_size;
   ASSERT_LE(group_size, compute_properties.maxGroupSizeX);
 
@@ -227,7 +222,7 @@ LZT_TEST_P(
   lzt::set_argument_value(function, 2, group_size * sizeof(int), nullptr);
 
   lzt::zeCommandBundle cmd_bundle = lzt::create_command_bundle(
-      lzt::get_default_context(), device, 0, ordinal, use_immediate_cmdlist);
+      lzt::get_default_context(), device, 0, *ordinal, use_immediate_cmdlist);
 
   ze_group_count_t thread_group_dimensions = {group_count, 1, 1};
   lzt::append_launch_cooperative_function(
diff --git a/utils/utils/include/utils/utils.hpp b/utils/utils/include/utils/utils.hpp
index 9a36d6b8..af7c3451 100644
--- a/utils/utils/include/utils/utils.hpp
+++ b/utils/utils/include/utils/utils.hpp
@@ -12,6 +12,7 @@
 #include <vector>
 #include <memory>
 #include <map>
+#include <optional>
 
 #include <level_zero/zet_api.h>
 #include <level_zero/zes_api.h>
@@ -91,6 +92,12 @@ uint32_t get_device_count(ze_driver_handle_t driver);
 uint32_t get_driver_handle_count();
 uint32_t get_sub_device_count(ze_device_handle_t device);
 
+std::optional<uint32_t>
+get_queue_ordinal(const std::vector<ze_command_queue_group_properties_t>
+                      &cmd_queue_group_props,
+                  ze_command_queue_group_property_flags_t include_flags,
+                  ze_command_queue_group_property_flags_t exclude_flags);
+
 void print_driver_version();
 void print_driver_overview(const ze_driver_handle_t driver);
 void print_driver_overview(const std::vector<ze_driver_handle_t> driver);
diff --git a/utils/utils/src/utils.cpp b/utils/utils/src/utils.cpp
index c6a314d5..a8f319d4 100644
--- a/utils/utils/src/utils.cpp
+++ b/utils/utils/src/utils.cpp
@@ -344,6 +344,20 @@ void sort_devices(std::vector<ze_device_handle_t> &devices) {
             });
 }
 
+std::optional<uint32_t>
+get_queue_ordinal(const std::vector<ze_command_queue_group_properties_t>
+                      &cmd_queue_group_props,
+                  ze_command_queue_group_property_flags_t include_flags,
+                  ze_command_queue_group_property_flags_t exclude_flags) {
+  for (uint32_t i = 0; i < cmd_queue_group_props.size(); i++) {
+    if ((cmd_queue_group_props[i].flags & include_flags) == include_flags &&
+        (cmd_queue_group_props[i].flags & exclude_flags) == 0) {
+      return i;
+    }
+  }
+  return std::nullopt;
+}
+
 void print_driver_version(ze_driver_handle_t driver) {
   ze_driver_properties_t properties = {};