From c79ee849274cca2ca7b6d1a32a8f6f0a15340f4b Mon Sep 17 00:00:00 2001
From: npmiller <nicolas.miller@codeplay.com>
Date: Mon, 12 Jul 2021 13:42:06 +0100
Subject: [PATCH] [SYCL] Skip PiCudaTests when running other plugins

This fixes an issue where if the cuda plugin is enabled and lit tests
for another plugin are run, it will try to run PiCudaTests, and all of
them will assert since the device filter will be set to a non-cuda
plugin and the tests request a cuda device.

So instead of asserting this patch makes the PiCudaTests get marked as
skipped if there is no cuda device found.
---
 sycl/unittests/pi/TestGetPlugin.hpp           |   7 +-
 sycl/unittests/pi/cuda/test_base_objects.cpp  |  49 ++++----
 sycl/unittests/pi/cuda/test_commands.cpp      |  39 ++++---
 sycl/unittests/pi/cuda/test_device.cpp        |  31 +++--
 sycl/unittests/pi/cuda/test_kernels.cpp       | 107 ++++++++++--------
 sycl/unittests/pi/cuda/test_mem_obj.cpp       |  63 ++++++-----
 sycl/unittests/pi/cuda/test_queue.cpp         |  45 ++++----
 .../pi/cuda/test_sampler_properties.cpp       |  33 +++---
 8 files changed, 212 insertions(+), 162 deletions(-)

diff --git a/sycl/unittests/pi/TestGetPlugin.hpp b/sycl/unittests/pi/TestGetPlugin.hpp
index 6512b111f8123..3b5fd14bd41d4 100644
--- a/sycl/unittests/pi/TestGetPlugin.hpp
+++ b/sycl/unittests/pi/TestGetPlugin.hpp
@@ -10,7 +10,7 @@
 #include <functional>
 
 namespace pi {
-inline cl::sycl::detail::plugin initializeAndGet(cl::sycl::backend backend) {
+inline cl::sycl::detail::plugin *initializeAndGet(cl::sycl::backend backend) {
   auto plugins = cl::sycl::detail::pi::initialize();
   auto it = std::find_if(plugins.begin(), plugins.end(),
                          [=](cl::sycl::detail::plugin p) -> bool {
@@ -19,9 +19,10 @@ inline cl::sycl::detail::plugin initializeAndGet(cl::sycl::backend backend) {
   if (it == plugins.end()) {
     std::string msg = GetBackendString(backend);
     msg += " PI plugin not found!";
-    throw std::runtime_error(msg);
+    std::cerr << "Warning: " << msg << " Tests using it will be skipped.\n";
+    return nullptr;
   }
-  return *it;
+  return &*it;
 }
 
 inline std::vector<cl::sycl::detail::plugin> initializeAndRemoveInvalid() {
diff --git a/sycl/unittests/pi/cuda/test_base_objects.cpp b/sycl/unittests/pi/cuda/test_base_objects.cpp
index 1ae64f981931c..1c34734f4f55c 100644
--- a/sycl/unittests/pi/cuda/test_base_objects.cpp
+++ b/sycl/unittests/pi/cuda/test_base_objects.cpp
@@ -24,7 +24,14 @@ using namespace cl::sycl;
 
 class CudaBaseObjectsTest : public ::testing::Test {
 protected:
-  detail::plugin plugin = pi::initializeAndGet(backend::cuda);
+  detail::plugin *plugin = pi::initializeAndGet(backend::cuda);
+
+  void SetUp() override {
+    // skip the tests if the CUDA backend is not available
+    if (!plugin) {
+      GTEST_SKIP();
+    }
+  }
 
   CudaBaseObjectsTest() = default;
 
@@ -35,14 +42,14 @@ TEST_F(CudaBaseObjectsTest, piContextCreate) {
   pi_uint32 numPlatforms = 0;
   pi_platform platform = nullptr;
   pi_device device;
-  ASSERT_EQ(plugin.getBackend(), backend::cuda);
+  ASSERT_EQ(plugin->getBackend(), backend::cuda);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piPlatformsGet>(
                 0, nullptr, &numPlatforms)),
             PI_SUCCESS)
       << "piPlatformsGet failed.\n";
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piPlatformsGet>(
                 numPlatforms, &platform, nullptr)),
             PI_SUCCESS)
       << "piPlatformsGet failed.\n";
@@ -50,13 +57,13 @@ TEST_F(CudaBaseObjectsTest, piContextCreate) {
   ASSERT_GE(numPlatforms, 1u);
   ASSERT_NE(platform, nullptr);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piDevicesGet>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piDevicesGet>(
                 platform, PI_DEVICE_TYPE_GPU, 1, &device, nullptr)),
             PI_SUCCESS)
       << "piDevicesGet failed.\n";
 
   pi_context ctxt = nullptr;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piContextCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piContextCreate>(
                 nullptr, 1, &device, nullptr, nullptr, &ctxt)),
             PI_SUCCESS)
       << "piContextCreate failed.\n";
@@ -79,24 +86,24 @@ TEST_F(CudaBaseObjectsTest, piContextCreatePrimaryTrue) {
   pi_platform platform;
   pi_device device;
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piPlatformsGet>(
                 0, nullptr, &numPlatforms)),
             PI_SUCCESS)
       << "piPlatformsGet failed.\n";
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piPlatformsGet>(
                 numPlatforms, &platform, nullptr)),
             PI_SUCCESS)
       << "piPlatformsGet failed.\n";
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piDevicesGet>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piDevicesGet>(
                 platform, PI_DEVICE_TYPE_GPU, 1, &device, nullptr)),
             PI_SUCCESS);
   pi_context_properties properties[] = {
       __SYCL_PI_CONTEXT_PROPERTIES_CUDA_PRIMARY, PI_TRUE, 0};
 
   pi_context ctxt;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piContextCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piContextCreate>(
                 properties, 1, &device, nullptr, nullptr, &ctxt)),
             PI_SUCCESS);
   EXPECT_NE(ctxt, nullptr);
@@ -115,7 +122,7 @@ TEST_F(CudaBaseObjectsTest, piContextCreatePrimaryTrue) {
   cuErr = cuCtxGetCurrent(&current);
   ASSERT_EQ(cuErr, CUDA_SUCCESS);
   ASSERT_EQ(current, cudaContext);
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piContextRelease>(ctxt)),
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piContextRelease>(ctxt)),
             PI_SUCCESS);
 }
 
@@ -124,24 +131,24 @@ TEST_F(CudaBaseObjectsTest, piContextCreatePrimaryFalse) {
   pi_platform platform;
   pi_device device;
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piPlatformsGet>(
                 0, nullptr, &numPlatforms)),
             PI_SUCCESS)
       << "piPlatformsGet failed.\n";
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piPlatformsGet>(
                 numPlatforms, &platform, nullptr)),
             PI_SUCCESS)
       << "piPlatformsGet failed.\n";
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piDevicesGet>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piDevicesGet>(
                 platform, PI_DEVICE_TYPE_GPU, 1, &device, nullptr)),
             PI_SUCCESS);
   pi_context_properties properties[] = {
       __SYCL_PI_CONTEXT_PROPERTIES_CUDA_PRIMARY, PI_FALSE, 0};
 
   pi_context ctxt;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piContextCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piContextCreate>(
                 properties, 1, &device, nullptr, nullptr, &ctxt)),
             PI_SUCCESS);
   EXPECT_NE(ctxt, nullptr);
@@ -160,7 +167,7 @@ TEST_F(CudaBaseObjectsTest, piContextCreatePrimaryFalse) {
   cuErr = cuCtxGetCurrent(&current);
   ASSERT_EQ(cuErr, CUDA_SUCCESS);
   ASSERT_EQ(current, cudaContext);
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piContextRelease>(ctxt)),
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piContextRelease>(ctxt)),
             PI_SUCCESS);
 }
 
@@ -169,22 +176,22 @@ TEST_F(CudaBaseObjectsTest, piContextCreateChildThread) {
   pi_platform platform;
   pi_device device;
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piPlatformsGet>(
                 0, nullptr, &numPlatforms)),
             PI_SUCCESS)
       << "piPlatformsGet failed.\n";
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piPlatformsGet>(
                 numPlatforms, &platform, nullptr)),
             PI_SUCCESS)
       << "piPlatformsGet failed.\n";
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piDevicesGet>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piDevicesGet>(
                 platform, PI_DEVICE_TYPE_GPU, 1, &device, nullptr)),
             PI_SUCCESS);
 
   pi_context ctxt;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piContextCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piContextCreate>(
                 nullptr, 1, &device, nullptr, nullptr, &ctxt)),
             PI_SUCCESS);
   EXPECT_NE(ctxt, nullptr);
@@ -215,6 +222,6 @@ TEST_F(CudaBaseObjectsTest, piContextCreateChildThread) {
 
   callContextFromOtherThread.join();
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piContextRelease>(ctxt)),
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piContextRelease>(ctxt)),
             PI_SUCCESS);
 }
diff --git a/sycl/unittests/pi/cuda/test_commands.cpp b/sycl/unittests/pi/cuda/test_commands.cpp
index 3235391f93425..d3d9ad4baf31e 100644
--- a/sycl/unittests/pi/cuda/test_commands.cpp
+++ b/sycl/unittests/pi/cuda/test_commands.cpp
@@ -21,7 +21,7 @@ using namespace cl::sycl;
 struct CudaCommandsTest : public ::testing::Test {
 
 protected:
-  detail::plugin plugin = pi::initializeAndGet(backend::cuda);
+  detail::plugin *plugin = pi::initializeAndGet(backend::cuda);
 
   pi_platform platform_;
   pi_device device_;
@@ -29,29 +29,34 @@ struct CudaCommandsTest : public ::testing::Test {
   pi_queue queue_;
 
   void SetUp() override {
+    // skip the tests if the CUDA backend is not available
+    if (!plugin) {
+      GTEST_SKIP();
+    }
+
     cuCtxSetCurrent(nullptr);
     pi_uint32 numPlatforms = 0;
-    ASSERT_EQ(plugin.getBackend(), backend::cuda);
+    ASSERT_EQ(plugin->getBackend(), backend::cuda);
 
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   0, nullptr, &numPlatforms)),
               PI_SUCCESS)
         << "piPlatformsGet failed.\n";
 
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   numPlatforms, &platform_, nullptr)),
               PI_SUCCESS)
         << "piPlatformsGet failed.\n";
 
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piDevicesGet>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piDevicesGet>(
                   platform_, PI_DEVICE_TYPE_GPU, 1, &device_, nullptr)),
               PI_SUCCESS);
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piContextCreate>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piContextCreate>(
                   nullptr, 1, &device_, nullptr, nullptr, &context_)),
               PI_SUCCESS);
     ASSERT_NE(context_, nullptr);
 
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueCreate>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piQueueCreate>(
                   context_, device_, 0, &queue_)),
               PI_SUCCESS);
     ASSERT_NE(queue_, nullptr);
@@ -60,8 +65,10 @@ struct CudaCommandsTest : public ::testing::Test {
   }
 
   void TearDown() override {
-    plugin.call<detail::PiApiKind::piQueueRelease>(queue_);
-    plugin.call<detail::PiApiKind::piContextRelease>(context_);
+    if (plugin) {
+      plugin->call<detail::PiApiKind::piQueueRelease>(queue_);
+      plugin->call<detail::PiApiKind::piContextRelease>(context_);
+    }
   }
 
   CudaCommandsTest() = default;
@@ -77,15 +84,15 @@ TEST_F(CudaCommandsTest, PIEnqueueReadBufferBlocking) {
 
   pi_mem memObj;
   ASSERT_EQ(
-      (plugin.call_nocheck<detail::PiApiKind::piMemBufferCreate>(
+      (plugin->call_nocheck<detail::PiApiKind::piMemBufferCreate>(
           context_, PI_MEM_FLAGS_ACCESS_RW, bytes, nullptr, &memObj, nullptr)),
       PI_SUCCESS);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEnqueueMemBufferWrite>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piEnqueueMemBufferWrite>(
                 queue_, memObj, true, 0, bytes, data, 0, nullptr, nullptr)),
             PI_SUCCESS);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEnqueueMemBufferRead>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piEnqueueMemBufferRead>(
                 queue_, memObj, true, 0, bytes, output, 0, nullptr, nullptr)),
             PI_SUCCESS);
 
@@ -107,22 +114,22 @@ TEST_F(CudaCommandsTest, PIEnqueueReadBufferNonBlocking) {
 
   pi_mem memObj;
   ASSERT_EQ(
-      (plugin.call_nocheck<detail::PiApiKind::piMemBufferCreate>(
+      (plugin->call_nocheck<detail::PiApiKind::piMemBufferCreate>(
           context_, PI_MEM_FLAGS_ACCESS_RW, bytes, nullptr, &memObj, nullptr)),
       PI_SUCCESS);
 
   pi_event cpIn, cpOut;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEnqueueMemBufferWrite>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piEnqueueMemBufferWrite>(
                 queue_, memObj, false, 0, bytes, data, 0, nullptr, &cpIn)),
             PI_SUCCESS);
   ASSERT_NE(cpIn, nullptr);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEnqueueMemBufferRead>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piEnqueueMemBufferRead>(
                 queue_, memObj, false, 0, bytes, output, 0, nullptr, &cpOut)),
             PI_SUCCESS);
   ASSERT_NE(cpOut, nullptr);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEventsWait>(1, &cpOut)),
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piEventsWait>(1, &cpOut)),
             PI_SUCCESS);
 
   bool isSame =
diff --git a/sycl/unittests/pi/cuda/test_device.cpp b/sycl/unittests/pi/cuda/test_device.cpp
index 7c8a5d756c3c7..ba048cada8b64 100644
--- a/sycl/unittests/pi/cuda/test_device.cpp
+++ b/sycl/unittests/pi/cuda/test_device.cpp
@@ -21,38 +21,45 @@ using namespace cl::sycl;
 struct CudaDeviceTests : public ::testing::Test {
 
 protected:
-  detail::plugin plugin = pi::initializeAndGet(backend::cuda);
+  detail::plugin *plugin = pi::initializeAndGet(backend::cuda);
 
   pi_platform platform_;
   pi_device device_;
   pi_context context_;
 
   void SetUp() override {
+    // skip the tests if the CUDA backend is not available
+    if (!plugin) {
+      GTEST_SKIP();
+    }
+
     pi_uint32 numPlatforms = 0;
-    ASSERT_EQ(plugin.getBackend(), backend::cuda);
+    ASSERT_EQ(plugin->getBackend(), backend::cuda);
 
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   0, nullptr, &numPlatforms)),
               PI_SUCCESS)
         << "piPlatformsGet failed.\n";
 
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   numPlatforms, &platform_, nullptr)),
               PI_SUCCESS)
         << "piPlatformsGet failed.\n";
 
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piDevicesGet>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piDevicesGet>(
                   platform_, PI_DEVICE_TYPE_GPU, 1, &device_, nullptr)),
               PI_SUCCESS);
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piContextCreate>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piContextCreate>(
                   nullptr, 1, &device_, nullptr, nullptr, &context_)),
               PI_SUCCESS);
     EXPECT_NE(context_, nullptr);
   }
 
   void TearDown() override {
-    plugin.call<detail::PiApiKind::piDeviceRelease>(device_);
-    plugin.call<detail::PiApiKind::piContextRelease>(context_);
+    if (plugin) {
+      plugin->call<detail::PiApiKind::piDeviceRelease>(device_);
+      plugin->call<detail::PiApiKind::piContextRelease>(context_);
+    }
   }
 
   CudaDeviceTests() = default;
@@ -63,7 +70,7 @@ TEST_F(CudaDeviceTests, PIDeviceGetInfoSimple) {
 
   size_t return_size = 0;
   pi_device_type device_type;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piDeviceGetInfo>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piDeviceGetInfo>(
                 device_, PI_DEVICE_INFO_TYPE, sizeof(pi_device_type),
                 &device_type, &return_size)),
             PI_SUCCESS);
@@ -73,7 +80,7 @@ TEST_F(CudaDeviceTests, PIDeviceGetInfoSimple) {
       PI_DEVICE_TYPE_GPU); // backend pre-defined value, device must be a GPU
 
   pi_device parent_device = nullptr;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piDeviceGetInfo>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piDeviceGetInfo>(
                 device_, PI_DEVICE_INFO_PARENT_DEVICE, sizeof(pi_device),
                 &parent_device, &return_size)),
             PI_SUCCESS);
@@ -82,7 +89,7 @@ TEST_F(CudaDeviceTests, PIDeviceGetInfoSimple) {
             nullptr); // backend pre-set value, device cannot have a parent
 
   pi_platform platform = nullptr;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piDeviceGetInfo>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piDeviceGetInfo>(
                 device_, PI_DEVICE_INFO_PLATFORM, sizeof(pi_platform),
                 &platform, &return_size)),
             PI_SUCCESS);
@@ -91,7 +98,7 @@ TEST_F(CudaDeviceTests, PIDeviceGetInfoSimple) {
                                   // test fixture platform
 
   cl_device_partition_property device_partition_property = -1;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piDeviceGetInfo>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piDeviceGetInfo>(
                 device_, PI_DEVICE_INFO_PARTITION_TYPE,
                 sizeof(cl_device_partition_property),
                 &device_partition_property, &return_size)),
diff --git a/sycl/unittests/pi/cuda/test_kernels.cpp b/sycl/unittests/pi/cuda/test_kernels.cpp
index 0b57e7eb82790..d43cd6a7cd8bd 100644
--- a/sycl/unittests/pi/cuda/test_kernels.cpp
+++ b/sycl/unittests/pi/cuda/test_kernels.cpp
@@ -24,35 +24,40 @@ using namespace cl::sycl;
 struct CudaKernelsTest : public ::testing::Test {
 
 protected:
-  detail::plugin plugin = pi::initializeAndGet(backend::cuda);
+  detail::plugin *plugin = pi::initializeAndGet(backend::cuda);
   pi_platform platform_;
   pi_device device_;
   pi_context context_;
   pi_queue queue_;
 
   void SetUp() override {
+    // skip the tests if the CUDA backend is not available
+    if (!plugin) {
+      GTEST_SKIP();
+    }
+
     pi_uint32 numPlatforms = 0;
-    ASSERT_EQ(plugin.getBackend(), backend::cuda);
+    ASSERT_EQ(plugin->getBackend(), backend::cuda);
 
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   0, nullptr, &numPlatforms)),
               PI_SUCCESS)
         << "piPlatformsGet failed.\n";
 
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   numPlatforms, &platform_, nullptr)),
               PI_SUCCESS)
         << "piPlatformsGet failed.\n";
 
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piDevicesGet>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piDevicesGet>(
                   platform_, PI_DEVICE_TYPE_GPU, 1, &device_, nullptr)),
               PI_SUCCESS);
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piContextCreate>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piContextCreate>(
                   nullptr, 1, &device_, nullptr, nullptr, &context_)),
               PI_SUCCESS);
     ASSERT_NE(context_, nullptr);
 
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueCreate>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piQueueCreate>(
                   context_, device_, 0, &queue_)),
               PI_SUCCESS);
     ASSERT_NE(queue_, nullptr);
@@ -60,9 +65,11 @@ struct CudaKernelsTest : public ::testing::Test {
   }
 
   void TearDown() override {
-    plugin.call<detail::PiApiKind::piDeviceRelease>(device_);
-    plugin.call<detail::PiApiKind::piQueueRelease>(queue_);
-    plugin.call<detail::PiApiKind::piContextRelease>(context_);
+    if (plugin) {
+      plugin->call<detail::PiApiKind::piDeviceRelease>(device_);
+      plugin->call<detail::PiApiKind::piQueueRelease>(queue_);
+      plugin->call<detail::PiApiKind::piContextRelease>(context_);
+    }
   }
 
   CudaKernelsTest() = default;
@@ -132,17 +139,17 @@ TEST_F(CudaKernelsTest, PICreateProgramAndKernel) {
 
   pi_program prog;
   pi_int32 binary_status = PI_SUCCESS;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piProgramCreateWithBinary>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piProgramCreateWithBinary>(
                 context_, 1, &device_, nullptr,
                 (const unsigned char **)&ptxSource, &binary_status, &prog)),
             PI_SUCCESS);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piProgramBuild>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piProgramBuild>(
                 prog, 1, &device_, "", nullptr, nullptr)),
             PI_SUCCESS);
 
   pi_kernel kern;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piKernelCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piKernelCreate>(
                 prog, "_Z8myKernelPi", &kern)),
             PI_SUCCESS);
   ASSERT_NE(kern, nullptr);
@@ -155,23 +162,23 @@ TEST_F(CudaKernelsTest, PIKernelArgumentSimple) {
   /// use it at some point in the future, pass it anyway and check the result.
   /// Same goes for all the other tests in this file.
   pi_int32 binary_status = PI_SUCCESS;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piProgramCreateWithBinary>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piProgramCreateWithBinary>(
                 context_, 1, &device_, nullptr,
                 (const unsigned char **)&ptxSource, &binary_status, &prog)),
             PI_SUCCESS);
   ASSERT_EQ(binary_status, PI_SUCCESS);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piProgramBuild>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piProgramBuild>(
                 prog, 1, &device_, "", nullptr, nullptr)),
             PI_SUCCESS);
 
   pi_kernel kern;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piKernelCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piKernelCreate>(
                 prog, "_Z8myKernelPi", &kern)),
             PI_SUCCESS);
 
   int number = 10;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piKernelSetArg>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piKernelSetArg>(
                 kern, 0, sizeof(int), &number)),
             PI_SUCCESS);
   const auto &kernArgs = kern->get_arg_indices();
@@ -184,23 +191,23 @@ TEST_F(CudaKernelsTest, PIKernelArgumentSetTwice) {
 
   pi_program prog;
   pi_int32 binary_status = PI_SUCCESS;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piProgramCreateWithBinary>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piProgramCreateWithBinary>(
                 context_, 1, &device_, nullptr,
                 (const unsigned char **)&ptxSource, &binary_status, &prog)),
             PI_SUCCESS);
   ASSERT_EQ(binary_status, PI_SUCCESS);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piProgramBuild>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piProgramBuild>(
                 prog, 1, &device_, "", nullptr, nullptr)),
             PI_SUCCESS);
 
   pi_kernel kern;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piKernelCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piKernelCreate>(
                 prog, "_Z8myKernelPi", &kern)),
             PI_SUCCESS);
 
   int number = 10;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piKernelSetArg>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piKernelSetArg>(
                 kern, 0, sizeof(int), &number)),
             PI_SUCCESS);
   const auto &kernArgs = kern->get_arg_indices();
@@ -209,7 +216,7 @@ TEST_F(CudaKernelsTest, PIKernelArgumentSetTwice) {
   ASSERT_EQ(storedValue, number);
 
   int otherNumber = 934;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piKernelSetArg>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piKernelSetArg>(
                 kern, 0, sizeof(int), &otherNumber)),
             PI_SUCCESS);
   const auto &kernArgs2 = kern->get_arg_indices();
@@ -222,29 +229,29 @@ TEST_F(CudaKernelsTest, PIKernelSetMemObj) {
 
   pi_program prog;
   pi_int32 binary_status = PI_SUCCESS;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piProgramCreateWithBinary>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piProgramCreateWithBinary>(
                 context_, 1, &device_, nullptr,
                 (const unsigned char **)&ptxSource, &binary_status, &prog)),
             PI_SUCCESS);
   ASSERT_EQ(binary_status, PI_SUCCESS);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piProgramBuild>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piProgramBuild>(
                 prog, 1, &device_, "", nullptr, nullptr)),
             PI_SUCCESS);
 
   pi_kernel kern;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piKernelCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piKernelCreate>(
                 prog, "_Z8myKernelPi", &kern)),
             PI_SUCCESS);
 
   size_t memSize = 1024u;
   pi_mem memObj;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemBufferCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piMemBufferCreate>(
                 context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj,
                 nullptr)),
             PI_SUCCESS);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piKernelSetArg>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piKernelSetArg>(
                 kern, 0, sizeof(pi_mem), &memObj)),
             PI_SUCCESS);
   const auto &kernArgs = kern->get_arg_indices();
@@ -257,29 +264,29 @@ TEST_F(CudaKernelsTest, PIkerneldispatch) {
 
   pi_program prog;
   pi_int32 binary_status = PI_SUCCESS;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piProgramCreateWithBinary>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piProgramCreateWithBinary>(
                 context_, 1, &device_, nullptr,
                 (const unsigned char **)&ptxSource, &binary_status, &prog)),
             PI_SUCCESS);
   ASSERT_EQ(binary_status, PI_SUCCESS);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piProgramBuild>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piProgramBuild>(
                 prog, 1, &device_, "", nullptr, nullptr)),
             PI_SUCCESS);
 
   pi_kernel kern;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piKernelCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piKernelCreate>(
                 prog, "_Z8myKernelPi", &kern)),
             PI_SUCCESS);
 
   size_t memSize = 1024u;
   pi_mem memObj;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemBufferCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piMemBufferCreate>(
                 context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj,
                 nullptr)),
             PI_SUCCESS);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piextKernelSetArgMemObj>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piextKernelSetArgMemObj>(
                 kern, 0, &memObj)),
             PI_SUCCESS);
 
@@ -287,12 +294,12 @@ TEST_F(CudaKernelsTest, PIkerneldispatch) {
   size_t globalWorkOffset[] = {0};
   size_t globalWorkSize[] = {1};
   size_t localWorkSize[] = {1};
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEnqueueKernelLaunch>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piEnqueueKernelLaunch>(
                 queue_, kern, workDim, globalWorkOffset, globalWorkSize,
                 localWorkSize, 0, nullptr, nullptr)),
             PI_SUCCESS);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemRelease>(memObj)),
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piMemRelease>(memObj)),
             PI_SUCCESS);
 }
 
@@ -300,39 +307,39 @@ TEST_F(CudaKernelsTest, PIkerneldispatchTwo) {
 
   pi_program prog;
   pi_int32 binary_status = PI_SUCCESS;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piProgramCreateWithBinary>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piProgramCreateWithBinary>(
                 context_, 1, &device_, nullptr,
                 (const unsigned char **)&twoParams, &binary_status, &prog)),
             PI_SUCCESS);
   ASSERT_EQ(binary_status, PI_SUCCESS);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piProgramBuild>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piProgramBuild>(
                 prog, 1, &device_, "", nullptr, nullptr)),
             PI_SUCCESS);
 
   pi_kernel kern;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piKernelCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piKernelCreate>(
                 prog, "twoParamKernel", &kern)),
             PI_SUCCESS);
 
   size_t memSize = 1024u;
   pi_mem memObj;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemBufferCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piMemBufferCreate>(
                 context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj,
                 nullptr)),
             PI_SUCCESS);
 
   pi_mem memObj2;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemBufferCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piMemBufferCreate>(
                 context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj2,
                 nullptr)),
             PI_SUCCESS);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piextKernelSetArgMemObj>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piextKernelSetArgMemObj>(
                 kern, 0, &memObj)),
             PI_SUCCESS);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piextKernelSetArgMemObj>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piextKernelSetArgMemObj>(
                 kern, 1, &memObj2)),
             PI_SUCCESS);
 
@@ -340,14 +347,14 @@ TEST_F(CudaKernelsTest, PIkerneldispatchTwo) {
   size_t globalWorkOffset[] = {0};
   size_t globalWorkSize[] = {1};
   size_t localWorkSize[] = {1};
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEnqueueKernelLaunch>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piEnqueueKernelLaunch>(
                 queue_, kern, workDim, globalWorkOffset, globalWorkSize,
                 localWorkSize, 0, nullptr, nullptr)),
             PI_SUCCESS);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemRelease>(memObj)),
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piMemRelease>(memObj)),
             PI_SUCCESS);
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemRelease>(memObj2)),
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piMemRelease>(memObj2)),
             PI_SUCCESS);
 }
 
@@ -356,23 +363,23 @@ TEST_F(CudaKernelsTest, PIKernelArgumentSetTwiceOneLocal) {
   pi_program prog;
   pi_int32 binary_status = PI_SUCCESS;
   ASSERT_EQ(
-      (plugin.call_nocheck<detail::PiApiKind::piProgramCreateWithBinary>(
+      (plugin->call_nocheck<detail::PiApiKind::piProgramCreateWithBinary>(
           context_, 1, &device_, nullptr,
           (const unsigned char **)&threeParamsTwoLocal, &binary_status, &prog)),
       PI_SUCCESS);
   ASSERT_EQ(binary_status, PI_SUCCESS);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piProgramBuild>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piProgramBuild>(
                 prog, 1, &device_, "", nullptr, nullptr)),
             PI_SUCCESS);
 
   pi_kernel kern;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piKernelCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piKernelCreate>(
                 prog, "twoParamKernelLocal", &kern)),
             PI_SUCCESS);
 
   int number = 10;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piKernelSetArg>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piKernelSetArg>(
                 kern, 0, sizeof(int), &number)),
             PI_SUCCESS);
   const auto &kernArgs = kern->get_arg_indices();
@@ -380,7 +387,7 @@ TEST_F(CudaKernelsTest, PIKernelArgumentSetTwiceOneLocal) {
   int storedValue = *(static_cast<const int *>(kernArgs[0]));
   ASSERT_EQ(storedValue, number);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piKernelSetArg>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piKernelSetArg>(
                 kern, 1, sizeof(int), nullptr)),
             PI_SUCCESS);
   const auto &kernArgs2 = kern->get_arg_indices();
@@ -388,7 +395,7 @@ TEST_F(CudaKernelsTest, PIKernelArgumentSetTwiceOneLocal) {
   storedValue = *(static_cast<const int *>(kernArgs2[1]));
   ASSERT_EQ(storedValue, 0);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piKernelSetArg>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piKernelSetArg>(
                 kern, 2, sizeof(int), nullptr)),
             PI_SUCCESS);
   const auto &kernArgs3 = kern->get_arg_indices();
diff --git a/sycl/unittests/pi/cuda/test_mem_obj.cpp b/sycl/unittests/pi/cuda/test_mem_obj.cpp
index cca3a43fc9a38..b3d85682279fc 100644
--- a/sycl/unittests/pi/cuda/test_mem_obj.cpp
+++ b/sycl/unittests/pi/cuda/test_mem_obj.cpp
@@ -22,39 +22,46 @@ using namespace cl::sycl;
 struct CudaTestMemObj : public ::testing::Test {
 
 protected:
-  detail::plugin plugin = pi::initializeAndGet(backend::cuda);
+  detail::plugin *plugin = pi::initializeAndGet(backend::cuda);
 
   pi_platform platform_;
   pi_device device_;
   pi_context context_;
 
   void SetUp() override {
+    // skip the tests if the CUDA backend is not available
+    if (!plugin) {
+      GTEST_SKIP();
+    }
+
     cuCtxSetCurrent(nullptr);
     pi_uint32 numPlatforms = 0;
-    ASSERT_EQ(plugin.getBackend(), backend::cuda);
+    ASSERT_EQ(plugin->getBackend(), backend::cuda);
 
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   0, nullptr, &numPlatforms)),
               PI_SUCCESS)
         << "piPlatformsGet failed.\n";
 
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   numPlatforms, &platform_, nullptr)),
               PI_SUCCESS)
         << "piPlatformsGet failed.\n";
 
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piDevicesGet>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piDevicesGet>(
                   platform_, PI_DEVICE_TYPE_GPU, 1, &device_, nullptr)),
               PI_SUCCESS);
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piContextCreate>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piContextCreate>(
                   nullptr, 1, &device_, nullptr, nullptr, &context_)),
               PI_SUCCESS);
     EXPECT_NE(context_, nullptr);
   }
 
   void TearDown() override {
-    plugin.call<detail::PiApiKind::piDeviceRelease>(device_);
-    plugin.call<detail::PiApiKind::piContextRelease>(context_);
+    if (plugin) {
+      plugin->call<detail::PiApiKind::piDeviceRelease>(device_);
+      plugin->call<detail::PiApiKind::piContextRelease>(context_);
+    }
   }
 
   CudaTestMemObj() = default;
@@ -65,24 +72,24 @@ struct CudaTestMemObj : public ::testing::Test {
 TEST_F(CudaTestMemObj, piMemBufferCreateSimple) {
   const size_t memSize = 1024u;
   pi_mem memObj;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemBufferCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piMemBufferCreate>(
                 context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj,
                 nullptr)),
             PI_SUCCESS);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemRelease>(memObj)),
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piMemRelease>(memObj)),
             PI_SUCCESS);
 }
 
 TEST_F(CudaTestMemObj, piMemBufferAllocHost) {
   const size_t memSize = 1024u;
   pi_mem memObj;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemBufferCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piMemBufferCreate>(
                 context_, PI_MEM_FLAGS_ACCESS_RW | PI_MEM_FLAGS_HOST_PTR_ALLOC,
                 memSize, nullptr, &memObj, nullptr)),
             PI_SUCCESS);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemRelease>(memObj)),
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piMemRelease>(memObj)),
             PI_SUCCESS);
 }
 
@@ -106,13 +113,13 @@ TEST_F(CudaTestMemObj, piMemBufferCreateNoActiveContext) {
   // The context object is passed, even if its not active it should be used
   // to allocate the memory object
   pi_mem memObj;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemBufferCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piMemBufferCreate>(
                 context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj,
                 nullptr)),
             PI_SUCCESS);
   ASSERT_NE(memObj, nullptr);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemRelease>(memObj)),
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piMemRelease>(memObj)),
             PI_SUCCESS);
 }
 
@@ -121,38 +128,38 @@ TEST_F(CudaTestMemObj, piMemBufferPinnedMappedRead) {
   const int value = 20;
 
   pi_queue queue;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piQueueCreate>(
                 context_, device_, 0, &queue)),
             PI_SUCCESS);
   ASSERT_NE(queue, nullptr);
   ASSERT_EQ(queue->get_context(), context_);
 
   pi_mem memObj;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemBufferCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piMemBufferCreate>(
                 context_, PI_MEM_FLAGS_ACCESS_RW | PI_MEM_FLAGS_HOST_PTR_ALLOC,
                 memSize, nullptr, &memObj, nullptr)),
             PI_SUCCESS);
 
   ASSERT_EQ(
-      (plugin.call_nocheck<detail::PiApiKind::piEnqueueMemBufferWrite>(
+      (plugin->call_nocheck<detail::PiApiKind::piEnqueueMemBufferWrite>(
           queue, memObj, true, 0, sizeof(int), &value, 0, nullptr, nullptr)),
       PI_SUCCESS);
 
   int *host_ptr = nullptr;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEnqueueMemBufferMap>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piEnqueueMemBufferMap>(
                 queue, memObj, true, PI_MAP_READ, 0, sizeof(int), 0, nullptr,
                 nullptr, (void **)&host_ptr)),
             PI_SUCCESS);
 
   ASSERT_EQ(*host_ptr, value);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEnqueueMemUnmap>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piEnqueueMemUnmap>(
                 queue, memObj, host_ptr, 0, nullptr, nullptr)),
             PI_SUCCESS);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemRelease>(memObj)),
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piMemRelease>(memObj)),
             PI_SUCCESS);
-  plugin.call<detail::PiApiKind::piQueueRelease>(queue);
+  plugin->call<detail::PiApiKind::piQueueRelease>(queue);
 }
 
 TEST_F(CudaTestMemObj, piMemBufferPinnedMappedWrite) {
@@ -160,39 +167,39 @@ TEST_F(CudaTestMemObj, piMemBufferPinnedMappedWrite) {
   const int value = 30;
 
   pi_queue queue;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piQueueCreate>(
                 context_, device_, 0, &queue)),
             PI_SUCCESS);
   ASSERT_NE(queue, nullptr);
   ASSERT_EQ(queue->get_context(), context_);
 
   pi_mem memObj;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemBufferCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piMemBufferCreate>(
                 context_, PI_MEM_FLAGS_ACCESS_RW | PI_MEM_FLAGS_HOST_PTR_ALLOC,
                 memSize, nullptr, &memObj, nullptr)),
             PI_SUCCESS);
 
   int *host_ptr = nullptr;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEnqueueMemBufferMap>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piEnqueueMemBufferMap>(
                 queue, memObj, true, PI_MAP_WRITE, 0, sizeof(int), 0, nullptr,
                 nullptr, (void **)&host_ptr)),
             PI_SUCCESS);
 
   *host_ptr = value;
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEnqueueMemUnmap>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piEnqueueMemUnmap>(
                 queue, memObj, host_ptr, 0, nullptr, nullptr)),
             PI_SUCCESS);
 
   int read_value = 0;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEnqueueMemBufferRead>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piEnqueueMemBufferRead>(
                 queue, memObj, true, 0, sizeof(int), &read_value, 0, nullptr,
                 nullptr)),
             PI_SUCCESS);
 
   ASSERT_EQ(read_value, value);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemRelease>(memObj)),
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piMemRelease>(memObj)),
             PI_SUCCESS);
-  plugin.call<detail::PiApiKind::piQueueRelease>(queue);
+  plugin->call<detail::PiApiKind::piQueueRelease>(queue);
 }
diff --git a/sycl/unittests/pi/cuda/test_queue.cpp b/sycl/unittests/pi/cuda/test_queue.cpp
index 2bb5ffbe2347f..979bbdca7b57d 100644
--- a/sycl/unittests/pi/cuda/test_queue.cpp
+++ b/sycl/unittests/pi/cuda/test_queue.cpp
@@ -24,38 +24,45 @@ using namespace sycl;
 struct CudaTestQueue : public ::testing::TestWithParam<platform> {
 
 protected:
-  detail::plugin plugin = pi::initializeAndGet(backend::cuda);
+  detail::plugin *plugin = pi::initializeAndGet(backend::cuda);
 
   pi_platform platform_;
   pi_device device_;
   pi_context context_;
 
   void SetUp() override {
+    // skip the tests if the CUDA backend is not available
+    if (!plugin) {
+      GTEST_SKIP();
+    }
+
     pi_uint32 numPlatforms = 0;
-    ASSERT_EQ(plugin.getBackend(), backend::cuda);
+    ASSERT_EQ(plugin->getBackend(), backend::cuda);
 
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   0, nullptr, &numPlatforms)),
               PI_SUCCESS)
         << "piPlatformsGet failed.\n";
 
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   numPlatforms, &platform_, nullptr)),
               PI_SUCCESS)
         << "piPlatformsGet failed.\n";
 
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piDevicesGet>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piDevicesGet>(
                   platform_, PI_DEVICE_TYPE_GPU, 1, &device_, nullptr)),
               PI_SUCCESS);
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piContextCreate>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piContextCreate>(
                   nullptr, 1, &device_, nullptr, nullptr, &context_)),
               PI_SUCCESS);
     EXPECT_NE(context_, nullptr);
   }
 
   void TearDown() override {
-    plugin.call<detail::PiApiKind::piDeviceRelease>(device_);
-    plugin.call<detail::PiApiKind::piContextRelease>(context_);
+    if (plugin) {
+      plugin->call<detail::PiApiKind::piDeviceRelease>(device_);
+      plugin->call<detail::PiApiKind::piContextRelease>(context_);
+    }
   }
 
   CudaTestQueue() = default;
@@ -65,7 +72,7 @@ struct CudaTestQueue : public ::testing::TestWithParam<platform> {
 
 TEST_F(CudaTestQueue, PICreateQueueSimple) {
   pi_queue queue;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piQueueCreate>(
                 context_, device_, 0, &queue)),
             PI_SUCCESS);
   ASSERT_NE(queue, nullptr);
@@ -76,13 +83,13 @@ TEST_F(CudaTestQueue, PICreateQueueSimple) {
   cuStreamGetFlags(stream, &flags);
   ASSERT_EQ(flags, CU_STREAM_NON_BLOCKING);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueRelease>(queue)),
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piQueueRelease>(queue)),
             PI_SUCCESS);
 }
 
 TEST_F(CudaTestQueue, PIQueueFinishSimple) {
   pi_queue queue;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piQueueCreate>(
                 context_, device_, 0, &queue)),
             PI_SUCCESS);
   ASSERT_NE(queue, nullptr);
@@ -90,18 +97,18 @@ TEST_F(CudaTestQueue, PIQueueFinishSimple) {
   // todo: post work on queue, ensure the results are valid and the work is
   // complete after piQueueFinish?
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueFinish>(queue)),
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piQueueFinish>(queue)),
             PI_SUCCESS);
 
   ASSERT_EQ(cuStreamQuery(queue->get()), CUDA_SUCCESS);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueRelease>(queue)),
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piQueueRelease>(queue)),
             PI_SUCCESS);
 }
 
 TEST_F(CudaTestQueue, PICreateQueueSimpleDefault) {
   pi_queue queue;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piQueueCreate>(
                 context_, device_, __SYCL_PI_CUDA_USE_DEFAULT_STREAM, &queue)),
             PI_SUCCESS);
   ASSERT_NE(queue, nullptr);
@@ -112,13 +119,13 @@ TEST_F(CudaTestQueue, PICreateQueueSimpleDefault) {
   cuStreamGetFlags(stream, &flags);
   ASSERT_EQ(flags, CU_STREAM_DEFAULT);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueRelease>(queue)),
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piQueueRelease>(queue)),
             PI_SUCCESS);
 }
 
 TEST_F(CudaTestQueue, PICreateQueueSyncWithDefault) {
   pi_queue queue;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piQueueCreate>(
                 context_, device_, __SYCL_PI_CUDA_SYNC_WITH_DEFAULT, &queue)),
             PI_SUCCESS);
   ASSERT_NE(queue, nullptr);
@@ -129,13 +136,13 @@ TEST_F(CudaTestQueue, PICreateQueueSyncWithDefault) {
   cuStreamGetFlags(stream, &flags);
   ASSERT_NE(flags, CU_STREAM_NON_BLOCKING);
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueRelease>(queue)),
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piQueueRelease>(queue)),
             PI_SUCCESS);
 }
 
 TEST_F(CudaTestQueue, PICreateQueueInterop) {
   pi_queue queue;
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueCreate>(
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piQueueCreate>(
                 context_, device_, 0, &queue)),
             PI_SUCCESS);
   ASSERT_NE(queue, nullptr);
@@ -148,7 +155,7 @@ TEST_F(CudaTestQueue, PICreateQueueInterop) {
   ASSERT_EQ(res, CUDA_SUCCESS);
   EXPECT_EQ(cuCtx, context_->get());
 
-  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueRelease>(queue)),
+  ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piQueueRelease>(queue)),
             PI_SUCCESS);
 }
 
diff --git a/sycl/unittests/pi/cuda/test_sampler_properties.cpp b/sycl/unittests/pi/cuda/test_sampler_properties.cpp
index 499faf5bb293c..dd6ae7faea22b 100644
--- a/sycl/unittests/pi/cuda/test_sampler_properties.cpp
+++ b/sycl/unittests/pi/cuda/test_sampler_properties.cpp
@@ -21,7 +21,7 @@ class SamplerPropertiesTest
     : public ::testing::TestWithParam<std::tuple<
           pi_bool, pi_sampler_filter_mode, pi_sampler_addressing_mode>> {
 protected:
-  detail::plugin plugin = pi::initializeAndGet(backend::cuda);
+  detail::plugin *plugin = pi::initializeAndGet(backend::cuda);
 
   pi_platform platform_;
   pi_device device_;
@@ -37,25 +37,30 @@ class SamplerPropertiesTest
   ~SamplerPropertiesTest() override = default;
 
   void SetUp() override {
+    // skip the tests if the CUDA backend is not available
+    if (plugin == nullptr) {
+      GTEST_SKIP();
+    }
+
     std::tie(normalizedCoords_, filterMode_, addressMode_) = GetParam();
 
     pi_uint32 numPlatforms = 0;
-    ASSERT_EQ(plugin.getBackend(), backend::cuda);
+    ASSERT_EQ(plugin->getBackend(), backend::cuda);
 
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   0, nullptr, &numPlatforms)),
               PI_SUCCESS)
         << "piPlatformsGet failed.\n";
 
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   numPlatforms, &platform_, nullptr)),
               PI_SUCCESS)
         << "piPlatformsGet failed.\n";
 
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piDevicesGet>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piDevicesGet>(
                   platform_, PI_DEVICE_TYPE_GPU, 1, &device_, nullptr)),
               PI_SUCCESS);
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piContextCreate>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piContextCreate>(
                   nullptr, 1, &device_, nullptr, nullptr, &context_)),
               PI_SUCCESS);
     EXPECT_NE(context_, nullptr);
@@ -69,22 +74,24 @@ class SamplerPropertiesTest
         filterMode_,
         0};
 
-    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piSamplerCreate>(
+    ASSERT_EQ((plugin->call_nocheck<detail::PiApiKind::piSamplerCreate>(
                   context_, sampler_properties, &sampler_)),
               PI_SUCCESS);
   }
 
   void TearDown() override {
-    plugin.call<detail::PiApiKind::piSamplerRelease>(sampler_);
-    plugin.call<detail::PiApiKind::piDeviceRelease>(device_);
-    plugin.call<detail::PiApiKind::piContextRelease>(context_);
+    if (plugin) {
+      plugin->call<detail::PiApiKind::piSamplerRelease>(sampler_);
+      plugin->call<detail::PiApiKind::piDeviceRelease>(device_);
+      plugin->call<detail::PiApiKind::piContextRelease>(context_);
+    }
   }
 };
 
 TEST_P(SamplerPropertiesTest, piCheckNormalizedCoords) {
   pi_bool actualNormalizedCoords = !normalizedCoords_;
 
-  plugin.call<detail::PiApiKind::piSamplerGetInfo>(
+  plugin->call<detail::PiApiKind::piSamplerGetInfo>(
       sampler_, PI_SAMPLER_INFO_NORMALIZED_COORDS, sizeof(pi_bool),
       &actualNormalizedCoords, nullptr);
 
@@ -94,7 +101,7 @@ TEST_P(SamplerPropertiesTest, piCheckNormalizedCoords) {
 TEST_P(SamplerPropertiesTest, piCheckFilterMode) {
   pi_sampler_filter_mode actualFilterMode;
 
-  plugin.call<detail::PiApiKind::piSamplerGetInfo>(
+  plugin->call<detail::PiApiKind::piSamplerGetInfo>(
       sampler_, PI_SAMPLER_INFO_FILTER_MODE, sizeof(pi_sampler_filter_mode),
       &actualFilterMode, nullptr);
 
@@ -104,7 +111,7 @@ TEST_P(SamplerPropertiesTest, piCheckFilterMode) {
 TEST_P(SamplerPropertiesTest, piCheckAddressingMode) {
   pi_sampler_addressing_mode actualAddressMode;
 
-  plugin.call<detail::PiApiKind::piSamplerGetInfo>(
+  plugin->call<detail::PiApiKind::piSamplerGetInfo>(
       sampler_, PI_SAMPLER_INFO_ADDRESSING_MODE,
       sizeof(pi_sampler_addressing_mode), &actualAddressMode, nullptr);