diff --git a/sycl/include/CL/sycl/detail/pi.h b/sycl/include/CL/sycl/detail/pi.h
index 49e569077f9fd..7da7d788e01ae 100644
--- a/sycl/include/CL/sycl/detail/pi.h
+++ b/sycl/include/CL/sycl/detail/pi.h
@@ -132,9 +132,16 @@ typedef enum {
 // make the translation to OpenCL transparent.
 //
 typedef enum : pi_uint64 {
-  PI_DEVICE_TYPE_CPU = CL_DEVICE_TYPE_CPU,
-  PI_DEVICE_TYPE_GPU = CL_DEVICE_TYPE_GPU,
-  PI_DEVICE_TYPE_ACC = CL_DEVICE_TYPE_ACCELERATOR
+  PI_DEVICE_TYPE_DEFAULT =
+      CL_DEVICE_TYPE_DEFAULT, ///< The default device available in the PI
+                              ///< plugin.
+  PI_DEVICE_TYPE_ALL =
+      CL_DEVICE_TYPE_ALL, ///< All devices available in the PI plugin.
+  PI_DEVICE_TYPE_CPU =
+      CL_DEVICE_TYPE_CPU, ///< A PI device that is the host processor.
+  PI_DEVICE_TYPE_GPU = CL_DEVICE_TYPE_GPU, ///< A PI device that is a GPU.
+  PI_DEVICE_TYPE_ACC = CL_DEVICE_TYPE_ACCELERATOR ///< A PI device that is a
+                                                  ///< dedicated accelerator.
 } _pi_device_type;
 
 typedef enum {
diff --git a/sycl/plugins/cuda/pi_cuda.cpp b/sycl/plugins/cuda/pi_cuda.cpp
index af15743438da8..fb2addafafacf 100644
--- a/sycl/plugins/cuda/pi_cuda.cpp
+++ b/sycl/plugins/cuda/pi_cuda.cpp
@@ -716,15 +716,18 @@ pi_result cuda_piDevicesGet(pi_platform platform, pi_device_type device_type,
                             pi_uint32 *num_devices) {
 
   pi_result err = PI_SUCCESS;
-  const bool askingForGPU = (device_type & PI_DEVICE_TYPE_GPU);
-  size_t numDevices = askingForGPU ? platform->devices_.size() : 0;
+  const bool askingForDefault = device_type == PI_DEVICE_TYPE_DEFAULT;
+  const bool askingForGPU = device_type & PI_DEVICE_TYPE_GPU;
+  const bool returnDevices = askingForDefault || askingForGPU;
+
+  size_t numDevices = returnDevices ? platform->devices_.size() : 0;
 
   try {
     if (num_devices) {
       *num_devices = numDevices;
     }
 
-    if (askingForGPU && devices) {
+    if (returnDevices && devices) {
       for (size_t i = 0; i < std::min(size_t(num_entries), numDevices); ++i) {
         devices[i] = platform->devices_[i].get();
       }
diff --git a/sycl/unittests/pi/BackendString.hpp b/sycl/unittests/pi/BackendString.hpp
new file mode 100644
index 0000000000000..ee3d212fc70ee
--- /dev/null
+++ b/sycl/unittests/pi/BackendString.hpp
@@ -0,0 +1,23 @@
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#pragma once
+
+#include <detail/plugin.hpp>
+
+namespace pi {
+inline const char *GetBackendString(cl::sycl::backend backend) {
+  switch (backend) {
+#define PI_BACKEND_STR(backend_name)                                           \
+  case cl::sycl::backend::backend_name:                                        \
+    return #backend_name
+    PI_BACKEND_STR(cuda);
+    PI_BACKEND_STR(host);
+    PI_BACKEND_STR(opencl);
+#undef PI_BACKEND_STR
+  default:
+    return "Unknown Plugin";
+  }
+}
+} // namespace pi
\ No newline at end of file
diff --git a/sycl/unittests/pi/CMakeLists.txt b/sycl/unittests/pi/CMakeLists.txt
index 814f7da464508..fbaf61fea440f 100644
--- a/sycl/unittests/pi/CMakeLists.txt
+++ b/sycl/unittests/pi/CMakeLists.txt
@@ -2,7 +2,7 @@ set(CMAKE_CXX_EXTENSIONS OFF)
 
 # Enable exception handling for these unit tests
 set(LLVM_REQUIRES_EH 1)
-add_sycl_unittest(PiTests OBJECT 
+add_sycl_unittest(PiTests OBJECT
   EnqueueMemTest.cpp
   PiMock.cpp
   PlatformTest.cpp
diff --git a/sycl/unittests/pi/EnqueueMemTest.cpp b/sycl/unittests/pi/EnqueueMemTest.cpp
index d8cbcee51eaeb..53bc06b365e21 100644
--- a/sycl/unittests/pi/EnqueueMemTest.cpp
+++ b/sycl/unittests/pi/EnqueueMemTest.cpp
@@ -6,6 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "BackendString.hpp"
 #include <CL/sycl/detail/pi.hpp>
 #include <detail/plugin.hpp>
 #include <gtest/gtest.h>
@@ -13,10 +14,8 @@
 using namespace cl::sycl;
 
 namespace {
-class DISABLED_EnqueueMemTest : public ::testing::Test {
+class EnqueueMemTest : public testing::TestWithParam<detail::plugin> {
 protected:
-  std::vector<detail::plugin> Plugins;
-
   constexpr static size_t _numElementsX = 8;
   constexpr static size_t _numElementsY = 4;
 
@@ -25,75 +24,76 @@ class DISABLED_EnqueueMemTest : public ::testing::Test {
   pi_queue _queue = nullptr;
   pi_mem _mem = nullptr;
 
-  DISABLED_EnqueueMemTest() = default;
+  EnqueueMemTest() = default;
 
-  ~DISABLED_EnqueueMemTest() = default;
+  ~EnqueueMemTest() = default;
 
   void SetUp() override {
-    Plugins = detail::pi::initialize();
-    ASSERT_FALSE(Plugins.empty());
+
+    detail::plugin plugin = GetParam();
 
     pi_platform platform = nullptr;
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   1, &platform, nullptr)),
               PI_SUCCESS);
 
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piDevicesGet>(
-                  platform, PI_DEVICE_TYPE_GPU, 1, &_device, nullptr)),
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piDevicesGet>(
+                  platform, PI_DEVICE_TYPE_DEFAULT, 1, &_device, nullptr)),
               PI_SUCCESS);
 
     pi_result result = PI_INVALID_VALUE;
-    result = Plugins[0].call_nocheck<detail::PiApiKind::piContextCreate>(
+    result = plugin.call_nocheck<detail::PiApiKind::piContextCreate>(
         nullptr, 1u, &_device, nullptr, nullptr, &_context);
     ASSERT_EQ(result, PI_SUCCESS);
 
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piQueueCreate>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueCreate>(
                   _context, _device, 0, &_queue)),
               PI_SUCCESS);
 
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piMemBufferCreate>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemBufferCreate>(
                   _context, 0, _numElementsX * _numElementsY * sizeof(pi_int32),
                   nullptr, &_mem)),
               PI_SUCCESS);
   }
 
   void TearDown() override {
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piMemRelease>(_mem)),
+
+    detail::plugin plugin = GetParam();
+
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemRelease>(_mem)),
+              PI_SUCCESS);
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueRelease>(_queue)),
               PI_SUCCESS);
     ASSERT_EQ(
-        (Plugins[0].call_nocheck<detail::PiApiKind::piQueueRelease>(_queue)),
+        (plugin.call_nocheck<detail::PiApiKind::piContextRelease>(_context)),
         PI_SUCCESS);
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piContextRelease>(
-                  _context)),
-              PI_SUCCESS);
   }
 
   template <typename T> void TestBufferFill(const T &pattern) {
 
+    detail::plugin plugin = GetParam();
+
     T inValues[_numElementsX] = {};
 
     for (size_t i = 0; i < _numElementsX; ++i) {
       ASSERT_NE(pattern, inValues[i]);
     }
 
-    ASSERT_EQ(
-        (Plugins[0].call_nocheck<detail::PiApiKind::piEnqueueMemBufferWrite>(
-            _queue, _mem, PI_TRUE, 0, _numElementsX * sizeof(T), inValues, 0,
-            nullptr, nullptr)),
-        PI_SUCCESS);
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEnqueueMemBufferWrite>(
+                  _queue, _mem, PI_TRUE, 0, _numElementsX * sizeof(T), inValues,
+                  0, nullptr, nullptr)),
+              PI_SUCCESS);
 
-    ASSERT_EQ(
-        (Plugins[0].call_nocheck<detail::PiApiKind::piEnqueueMemBufferFill>(
-            _queue, _mem, &pattern, sizeof(T), 0, sizeof(inValues), 0, nullptr,
-            nullptr)),
-        PI_SUCCESS);
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEnqueueMemBufferFill>(
+                  _queue, _mem, &pattern, sizeof(T), 0, sizeof(inValues), 0,
+                  nullptr, nullptr)),
+              PI_SUCCESS);
 
     T outValues[_numElementsX] = {};
-    ASSERT_EQ(
-        (Plugins[0].call_nocheck<detail::PiApiKind::piEnqueueMemBufferRead>(
-            _queue, _mem, PI_TRUE, 0, _numElementsX * sizeof(T), outValues, 0,
-            nullptr, nullptr)),
-        PI_SUCCESS);
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEnqueueMemBufferRead>(
+                  _queue, _mem, PI_TRUE, 0, _numElementsX * sizeof(T),
+                  outValues, 0, nullptr, nullptr)),
+              PI_SUCCESS);
 
     for (size_t i = 0; i < _numElementsX; ++i) {
       ASSERT_EQ(pattern, outValues[i]);
@@ -101,48 +101,48 @@ class DISABLED_EnqueueMemTest : public ::testing::Test {
   }
 };
 
-template<typename T>
-struct vec4 {
+static std::vector<detail::plugin> Plugins = detail::pi::initialize();
+
+INSTANTIATE_TEST_CASE_P(
+    EnqueueMemTestImpl, EnqueueMemTest, testing::ValuesIn(Plugins),
+    [](const testing::TestParamInfo<EnqueueMemTest::ParamType> &info) {
+      return pi::GetBackendString(info.param.getBackend());
+    });
+
+template <typename T> struct vec4 {
   T x, y, z, w;
 
   bool operator==(const vec4 &rhs) const {
     return x == rhs.x && y == rhs.y && z == rhs.z && w == rhs.w;
   }
 
-  bool operator!=(const vec4 &rhs) const {
-    return !(*this == rhs);
-  }
+  bool operator!=(const vec4 &rhs) const { return !(*this == rhs); }
 };
 
-template<typename T>
-struct vec2 {
+template <typename T> struct vec2 {
   T x, y;
 
-  bool operator==(const vec2 &rhs) const {
-    return x == rhs.x && y == rhs.y;
-  }
+  bool operator==(const vec2 &rhs) const { return x == rhs.x && y == rhs.y; }
 
-  bool operator!=(const vec2 &rhs) const {
-    return !(*this == rhs);
-  }
+  bool operator!=(const vec2 &rhs) const { return !(*this == rhs); }
 };
 
-TEST_F(DISABLED_EnqueueMemTest, piEnqueueMemBufferFill) {
+TEST_P(EnqueueMemTest, piEnqueueMemBufferFill) {
 
-    TestBufferFill(float{1});
-    TestBufferFill(vec2<float>{1, 2});
-    TestBufferFill(vec4<float>{1, 2, 3, 4});
+  TestBufferFill(float{1});
+  TestBufferFill(vec2<float>{1, 2});
+  TestBufferFill(vec4<float>{1, 2, 3, 4});
 
-    TestBufferFill(uint8_t{1});
-    TestBufferFill(vec2<uint8_t>{1, 2});
-    TestBufferFill(vec4<uint8_t>{1, 2, 3, 4});
+  TestBufferFill(uint8_t{1});
+  TestBufferFill(vec2<uint8_t>{1, 2});
+  TestBufferFill(vec4<uint8_t>{1, 2, 3, 4});
 
-    TestBufferFill(uint16_t{1});
-    TestBufferFill(vec2<uint16_t>{1, 2});
-    TestBufferFill(vec4<uint16_t>{1, 2, 3, 4});
+  TestBufferFill(uint16_t{1});
+  TestBufferFill(vec2<uint16_t>{1, 2});
+  TestBufferFill(vec4<uint16_t>{1, 2, 3, 4});
 
-    TestBufferFill(uint32_t{1});
-    TestBufferFill(vec2<uint32_t>{1, 2});
-    TestBufferFill(vec4<uint32_t>{1, 2, 3, 4});
+  TestBufferFill(uint32_t{1});
+  TestBufferFill(vec2<uint32_t>{1, 2});
+  TestBufferFill(vec4<uint32_t>{1, 2, 3, 4});
 }
 } // namespace
diff --git a/sycl/unittests/pi/EventTest.cpp b/sycl/unittests/pi/EventTest.cpp
index d3c88b9db97a7..7260c39b5707b 100644
--- a/sycl/unittests/pi/EventTest.cpp
+++ b/sycl/unittests/pi/EventTest.cpp
@@ -6,57 +6,55 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "BackendString.hpp"
 #include "CL/sycl/detail/pi.hpp"
-#include <detail/plugin.hpp>
 #include <atomic>
+#include <detail/plugin.hpp>
 #include <gtest/gtest.h>
 #include <thread>
 
 using namespace cl::sycl;
 
 namespace pi {
-class DISABLED_EventTest : public ::testing::Test {
+class EventTest : public testing::TestWithParam<detail::plugin> {
 protected:
-  std::vector<detail::plugin> Plugins;
-
   pi_platform _platform;
   pi_context _context;
   pi_queue _queue;
   pi_device _device;
   pi_result _result;
 
-  DISABLED_EventTest()
+  EventTest()
       : _context{nullptr}, _queue{nullptr}, _device{nullptr},
-        _result{PI_INVALID_VALUE} {
-    Plugins = detail::pi::initialize();
-  }
+        _result{PI_INVALID_VALUE} {}
 
-  ~DISABLED_EventTest() override = default;
+  ~EventTest() override = default;
 
   void SetUp() override {
     pi_uint32 numPlatforms = 0;
-    ASSERT_FALSE(Plugins.empty());
 
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    detail::plugin plugin = GetParam();
+
+    RecordProperty("PiBackend", GetBackendString(plugin.getBackend()));
+
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   0, nullptr, &numPlatforms)),
-              PI_SUCCESS)
-        << "piPlatformsGet failed.\n";
+              PI_SUCCESS);
 
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   numPlatforms, &_platform, nullptr)),
-              PI_SUCCESS)
-        << "piPlatformsGet failed.\n";
+              PI_SUCCESS);
     (void)numPlatforms; // Deal with unused variable warning
 
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piDevicesGet>(
-                  _platform, PI_DEVICE_TYPE_GPU, 1, &_device, nullptr)),
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piDevicesGet>(
+                  _platform, PI_DEVICE_TYPE_DEFAULT, 1, &_device, nullptr)),
               PI_SUCCESS);
 
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piContextCreate>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piContextCreate>(
                   nullptr, 1, &_device, nullptr, nullptr, &_context)),
               PI_SUCCESS);
 
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piQueueCreate>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueCreate>(
                   _context, _device, 0, &_queue)),
               PI_SUCCESS);
 
@@ -65,27 +63,39 @@ class DISABLED_EventTest : public ::testing::Test {
 
   void TearDown() override {
 
-    ASSERT_EQ(
-        (Plugins[0].call_nocheck<detail::PiApiKind::piQueueRelease>(_queue)),
-        PI_SUCCESS);
+    detail::plugin plugin = GetParam();
 
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piContextRelease>(
-                  _context)),
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueRelease>(_queue)),
               PI_SUCCESS);
+
+    ASSERT_EQ(
+        (plugin.call_nocheck<detail::PiApiKind::piContextRelease>(_context)),
+        PI_SUCCESS);
   }
 };
 
+static std::vector<detail::plugin> Plugins = detail::pi::initialize();
+
+INSTANTIATE_TEST_CASE_P(
+    EventTestImpl, EventTest, testing::ValuesIn(Plugins),
+    [](const testing::TestParamInfo<EventTest::ParamType> &info) {
+      return pi::GetBackendString(info.param.getBackend());
+    });
+
 // TODO: need more negative tests to show errors being reported when expected
 // (invalid arguments etc).
 
-TEST_F(DISABLED_EventTest, PICreateEvent) {
+TEST_P(EventTest, PICreateEvent) {
   pi_event foo;
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventCreate>(_context,
-                                                                       &foo)),
-            PI_SUCCESS);
+
+  detail::plugin plugin = GetParam();
+
+  ASSERT_EQ(
+      (plugin.call_nocheck<detail::PiApiKind::piEventCreate>(_context, &foo)),
+      PI_SUCCESS);
   ASSERT_NE(foo, nullptr);
 
-  EXPECT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventRelease>(foo)),
+  EXPECT_EQ((plugin.call_nocheck<detail::PiApiKind::piEventRelease>(foo)),
             PI_SUCCESS);
 }
 
@@ -110,7 +120,9 @@ void EventCallback(pi_event event, pi_int32 status, void *data) {
   triggered_flag[pdata->index] = true;
 }
 
-TEST_F(DISABLED_EventTest, piEventSetCallback) {
+TEST_P(EventTest, piEventSetCallback) {
+
+  detail::plugin plugin = GetParam();
 
   pi_int32 event_callback_types[event_type_count] = {
       PI_EVENT_SUBMITTED, PI_EVENT_RUNNING, PI_EVENT_COMPLETE};
@@ -120,8 +132,8 @@ TEST_F(DISABLED_EventTest, piEventSetCallback) {
   // gate event lets us register callbacks before letting the enqueued work be
   // executed.
   pi_event gateEvent;
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventCreate>(
-                _context, &gateEvent)),
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEventCreate>(_context,
+                                                                   &gateEvent)),
             PI_SUCCESS);
 
   constexpr const size_t dataCount = 1000u;
@@ -130,58 +142,57 @@ TEST_F(DISABLED_EventTest, piEventSetCallback) {
 
   pi_mem memObj;
   ASSERT_EQ(
-      (Plugins[0].call_nocheck<detail::PiApiKind::piMemBufferCreate>(
+      (plugin.call_nocheck<detail::PiApiKind::piMemBufferCreate>(
           _context, PI_MEM_FLAGS_ACCESS_RW, size_in_bytes, nullptr, &memObj)),
       PI_SUCCESS);
 
   pi_event syncEvent;
-  ASSERT_EQ(
-      (Plugins[0].call_nocheck<detail::PiApiKind::piEnqueueMemBufferWrite>(
-          _queue, memObj, false, 0, size_in_bytes, data.data(), 1, &gateEvent,
-          &syncEvent)),
-      PI_SUCCESS);
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEnqueueMemBufferWrite>(
+                _queue, memObj, false, 0, size_in_bytes, data.data(), 1,
+                &gateEvent, &syncEvent)),
+            PI_SUCCESS);
 
   for (size_t i = 0; i < event_type_count; i++) {
     user_data[i].event_type = event_callback_types[i];
     user_data[i].index = i;
     ASSERT_EQ(
-        (Plugins[0].call_nocheck<detail::PiApiKind::piEventSetCallback>(
+        (plugin.call_nocheck<detail::PiApiKind::piEventSetCallback>(
             syncEvent, event_callback_types[i], EventCallback, user_data + i)),
         PI_SUCCESS);
   }
 
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventSetStatus>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEventSetStatus>(
                 gateEvent, PI_EVENT_COMPLETE)),
             PI_SUCCESS);
   ASSERT_EQ(
-      (Plugins[0].call_nocheck<detail::PiApiKind::piEventsWait>(1, &syncEvent)),
+      (plugin.call_nocheck<detail::PiApiKind::piEventsWait>(1, &syncEvent)),
       PI_SUCCESS);
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piQueueFinish>(_queue)),
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueFinish>(_queue)),
             PI_SUCCESS);
 
   for (size_t k = 0; k < event_type_count; ++k) {
     EXPECT_TRUE(triggered_flag[k]);
   }
 
-  ASSERT_EQ(
-      (Plugins[0].call_nocheck<detail::PiApiKind::piEventRelease>(gateEvent)),
-      PI_SUCCESS);
-  ASSERT_EQ(
-      (Plugins[0].call_nocheck<detail::PiApiKind::piEventRelease>(syncEvent)),
-      PI_SUCCESS);
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEventRelease>(gateEvent)),
+            PI_SUCCESS);
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEventRelease>(syncEvent)),
+            PI_SUCCESS);
 }
 
-TEST_F(DISABLED_EventTest, piEventGetInfo) {
+TEST_P(EventTest, piEventGetInfo) {
+
+  detail::plugin plugin = GetParam();
 
   pi_event foo;
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventCreate>(_context,
-                                                                       &foo)),
-            PI_SUCCESS);
+  ASSERT_EQ(
+      (plugin.call_nocheck<detail::PiApiKind::piEventCreate>(_context, &foo)),
+      PI_SUCCESS);
   ASSERT_NE(foo, nullptr);
 
   pi_uint64 paramValue = 0;
   pi_uint64 retSize = 0;
-  EXPECT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventGetInfo>(
+  EXPECT_EQ((plugin.call_nocheck<detail::PiApiKind::piEventGetInfo>(
                 foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue),
                 &paramValue, &retSize)),
             PI_SUCCESS);
@@ -189,51 +200,55 @@ TEST_F(DISABLED_EventTest, piEventGetInfo) {
   EXPECT_EQ(retSize, sizeof(pi_int32));
   EXPECT_EQ(paramValue, PI_EVENT_SUBMITTED);
 
-  EXPECT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventRelease>(foo)),
+  EXPECT_EQ((plugin.call_nocheck<detail::PiApiKind::piEventRelease>(foo)),
             PI_SUCCESS);
 }
 
-TEST_F(DISABLED_EventTest, piEventSetStatus) {
+TEST_P(EventTest, piEventSetStatus) {
+
+  detail::plugin plugin = GetParam();
 
   pi_event foo;
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventCreate>(_context,
-                                                                       &foo)),
-            PI_SUCCESS);
+  ASSERT_EQ(
+      (plugin.call_nocheck<detail::PiApiKind::piEventCreate>(_context, &foo)),
+      PI_SUCCESS);
   ASSERT_NE(foo, nullptr);
 
   pi_event_status paramValue = PI_EVENT_QUEUED;
   size_t retSize = 0u;
-  Plugins[0].call_nocheck<detail::PiApiKind::piEventGetInfo>(
+  plugin.call_nocheck<detail::PiApiKind::piEventGetInfo>(
       foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue),
       &paramValue, &retSize);
 
-  EXPECT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventSetStatus>(
+  EXPECT_EQ((plugin.call_nocheck<detail::PiApiKind::piEventSetStatus>(
                 foo, PI_EVENT_COMPLETE)),
             PI_SUCCESS);
 
   paramValue = {};
   retSize = 0u;
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventGetInfo>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEventGetInfo>(
                 foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue),
                 &paramValue, &retSize)),
             PI_SUCCESS);
   ASSERT_EQ(paramValue, PI_EVENT_COMPLETE);
 
-  EXPECT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventRelease>(foo)),
+  EXPECT_EQ((plugin.call_nocheck<detail::PiApiKind::piEventRelease>(foo)),
             PI_SUCCESS);
 }
 
-TEST_F(DISABLED_EventTest, WaitForManualEventOnOtherThread) {
+TEST_P(EventTest, WaitForManualEventOnOtherThread) {
+
+  detail::plugin plugin = GetParam();
 
   pi_event foo;
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventCreate>(_context,
-                                                                       &foo)),
-            PI_SUCCESS);
+  ASSERT_EQ(
+      (plugin.call_nocheck<detail::PiApiKind::piEventCreate>(_context, &foo)),
+      PI_SUCCESS);
   ASSERT_NE(foo, nullptr);
 
   pi_event_status paramValue = {};
   size_t retSize = 0u;
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventGetInfo>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEventGetInfo>(
                 foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue),
                 &paramValue, &retSize)),
             PI_SUCCESS);
@@ -243,15 +258,14 @@ TEST_F(DISABLED_EventTest, WaitForManualEventOnOtherThread) {
 
   auto tWaiter = std::thread([&]() {
     started = true;
-    ASSERT_EQ(
-        (Plugins[0].call_nocheck<detail::PiApiKind::piEventsWait>(1, &foo)),
-        PI_SUCCESS);
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEventsWait>(1, &foo)),
+              PI_SUCCESS);
   });
 
   while (!started) {
   };
 
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventSetStatus>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEventSetStatus>(
                 foo, PI_EVENT_COMPLETE)),
             PI_SUCCESS);
 
@@ -259,17 +273,19 @@ TEST_F(DISABLED_EventTest, WaitForManualEventOnOtherThread) {
 
   paramValue = {};
   retSize = 0u;
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventGetInfo>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEventGetInfo>(
                 foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue),
                 &paramValue, &retSize)),
             PI_SUCCESS);
   ASSERT_EQ(paramValue, PI_EVENT_COMPLETE);
 
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventRelease>(foo)),
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEventRelease>(foo)),
             PI_SUCCESS);
 }
 
-TEST_F(DISABLED_EventTest, piEnqueueEventsWait) {
+TEST_P(EventTest, piEnqueueEventsWait) {
+
+  detail::plugin plugin = GetParam();
 
   constexpr const size_t dataCount = 10u;
   int output[dataCount] = {};
@@ -277,53 +293,52 @@ TEST_F(DISABLED_EventTest, piEnqueueEventsWait) {
   constexpr const size_t bytes = sizeof(data);
 
   pi_mem memObj;
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piMemBufferCreate>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemBufferCreate>(
                 _context, PI_MEM_FLAGS_ACCESS_RW, bytes, nullptr, &memObj)),
             PI_SUCCESS);
 
   pi_event events[4] = {nullptr, nullptr, nullptr, nullptr};
 
-  ASSERT_EQ(
-      (Plugins[0].call_nocheck<detail::PiApiKind::piEnqueueMemBufferWrite>(
-          _queue, memObj, true, 0, bytes, data, 0, nullptr, &events[0])),
-      PI_SUCCESS);
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEnqueueMemBufferWrite>(
+                _queue, memObj, true, 0, bytes, data, 0, nullptr, &events[0])),
+            PI_SUCCESS);
   ASSERT_NE(events[0], nullptr);
 
   ASSERT_EQ(
-      (Plugins[0].call_nocheck<detail::PiApiKind::piEnqueueMemBufferRead>(
+      (plugin.call_nocheck<detail::PiApiKind::piEnqueueMemBufferRead>(
           _queue, memObj, true, 0, bytes, output, 0, nullptr, &events[1])),
       PI_SUCCESS);
   ASSERT_NE(events[1], nullptr);
 
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventCreate>(
-                _context, &events[2])),
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEventCreate>(_context,
+                                                                   &events[2])),
             PI_SUCCESS);
   ASSERT_NE(events[2], nullptr);
 
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEnqueueEventsWait>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEnqueueEventsWait>(
                 _queue, 3, events, &events[3])),
             PI_SUCCESS);
   ASSERT_NE(events[3], nullptr);
 
   pi_event_status paramValue = {};
   size_t retSize = 0u;
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventGetInfo>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEventGetInfo>(
                 events[3], PI_EVENT_INFO_COMMAND_EXECUTION_STATUS,
                 sizeof(paramValue), &paramValue, &retSize)),
             PI_SUCCESS);
   ASSERT_NE(paramValue, PI_EVENT_COMPLETE);
 
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventSetStatus>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEventSetStatus>(
                 events[2], PI_EVENT_COMPLETE)),
             PI_SUCCESS);
 
   ASSERT_EQ(
-      (Plugins[0].call_nocheck<detail::PiApiKind::piEventsWait>(1, &events[3])),
+      (plugin.call_nocheck<detail::PiApiKind::piEventsWait>(1, &events[3])),
       PI_SUCCESS);
 
   paramValue = {};
   retSize = 0u;
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventGetInfo>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEventGetInfo>(
                 events[3], PI_EVENT_INFO_COMMAND_EXECUTION_STATUS,
                 sizeof(paramValue), &paramValue, &retSize)),
             PI_SUCCESS);
diff --git a/sycl/unittests/pi/PiMock.cpp b/sycl/unittests/pi/PiMock.cpp
index 0f415a3b23aa4..88d727a0f0968 100644
--- a/sycl/unittests/pi/PiMock.cpp
+++ b/sycl/unittests/pi/PiMock.cpp
@@ -8,7 +8,6 @@
 
 #include <gtest/gtest.h>
 #include <helpers/PiMock.hpp>
-
 #include <detail/queue_impl.hpp>
 
 using namespace cl::sycl;
diff --git a/sycl/unittests/pi/PlatformTest.cpp b/sycl/unittests/pi/PlatformTest.cpp
index f04f6dea2de09..ec9e4431aaa65 100644
--- a/sycl/unittests/pi/PlatformTest.cpp
+++ b/sycl/unittests/pi/PlatformTest.cpp
@@ -6,6 +6,7 @@
 //
 //===----------------------------------------------------------------------===//
 
+#include "BackendString.hpp"
 #include <CL/sycl.hpp>
 #include <CL/sycl/detail/pi.hpp>
 #include <detail/plugin.hpp>
@@ -16,15 +17,17 @@ namespace {
 
 using namespace cl::sycl;
 
-class PlatformTest : public ::testing::Test {
+class PlatformTest : public testing::TestWithParam<detail::plugin> {
 protected:
   std::vector<pi_platform> _platforms;
-  std::vector<detail::plugin> Plugins;
-  PlatformTest() : _platforms{} { Plugins = detail::pi::initialize(); };
+  PlatformTest() : _platforms{} {};
 
   ~PlatformTest() override = default;
 
   void SetUp() {
+
+    detail::plugin plugin = GetParam();
+
     ASSERT_NO_FATAL_FAILURE(Test::SetUp());
 
     const static char *platform_count_key = "PiPlatformCount";
@@ -36,7 +39,7 @@ class PlatformTest : public ::testing::Test {
 
     // TODO: Change the test to check this for all plugins present.
     // Currently, it is only checking for the first plugin attached.
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   0, nullptr, &platform_count)),
               PI_SUCCESS);
 
@@ -44,8 +47,7 @@ class PlatformTest : public ::testing::Test {
     RecordProperty(platform_count_key, platform_count);
 
     if (platform_count == 0u) {
-      std::cout
-          << "WARNING: piPlatformsGet does not find any PI platforms.\n";
+      std::cout << "WARNING: piPlatformsGet does not find any PI platforms.\n";
 
       // Do not call into OpenCL below as a platform count of 0 might fail with
       // OpenCL implementations if the platforms pointer is not `nullptr`.
@@ -54,28 +56,39 @@ class PlatformTest : public ::testing::Test {
 
     _platforms.resize(platform_count, nullptr);
 
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   _platforms.size(), _platforms.data(), nullptr)),
               PI_SUCCESS);
   }
 };
 
-TEST_F(PlatformTest, piPlatformsGet) {
+static std::vector<detail::plugin> Plugins = detail::pi::initialize();
+
+INSTANTIATE_TEST_CASE_P(
+    PlatformTestImpl, PlatformTest, testing::ValuesIn(Plugins),
+    [](const testing::TestParamInfo<PlatformTest::ParamType> &info) {
+      return pi::GetBackendString(info.param.getBackend());
+    });
+
+TEST_P(PlatformTest, piPlatformsGet) {
   // The PlatformTest::SetUp method is called to prepare for this test case
   // implicitly tests the calls to `piPlatformsGet`.
 }
 
-TEST_F(PlatformTest, piPlatformGetInfo) {
+TEST_P(PlatformTest, piPlatformGetInfo) {
+
+  detail::plugin plugin = GetParam();
+
   auto get_info_test = [&](pi_platform platform, _pi_platform_info info) {
     size_t reported_string_length = 0;
-    EXPECT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformGetInfo>(
+    EXPECT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformGetInfo>(
                   platform, info, 0u, nullptr, &reported_string_length)),
               PI_SUCCESS);
 
     // Create a larger result string to catch overwrites.
     std::vector<char> param_value(reported_string_length * 2u, '\0');
     EXPECT_EQ(
-        (Plugins[0].call_nocheck<detail::PiApiKind::piPlatformGetInfo>(
+        (plugin.call_nocheck<detail::PiApiKind::piPlatformGetInfo>(
             platform, info, param_value.size(), param_value.data(), nullptr)),
         PI_SUCCESS)
         << "piPlatformGetInfo for " << detail::pi::platformInfoToString(info)
diff --git a/sycl/unittests/pi/cuda/test_base_objects.cpp b/sycl/unittests/pi/cuda/test_base_objects.cpp
index 34c361a5c43f1..307c1d7ba1897 100644
--- a/sycl/unittests/pi/cuda/test_base_objects.cpp
+++ b/sycl/unittests/pi/cuda/test_base_objects.cpp
@@ -10,6 +10,7 @@
 
 #include <cuda.h>
 
+#include "test_get_plugin.hpp"
 #include <CL/sycl.hpp>
 #include <CL/sycl/detail/cuda_definitions.hpp>
 #include <CL/sycl/detail/pi.hpp>
@@ -21,27 +22,27 @@ const unsigned int LATEST_KNOWN_CUDA_DRIVER_API_VERSION = 3020u;
 
 using namespace cl::sycl;
 
-class DISABLED_CudaBaseObjectsTest : public ::testing::Test {
+class CudaBaseObjectsTest : public ::testing::Test {
 protected:
-  std::vector<detail::plugin> Plugins;
+  detail::plugin plugin = pi::initializeAndGetCuda();
 
-  DISABLED_CudaBaseObjectsTest() { Plugins = detail::pi::initialize(); }
+  CudaBaseObjectsTest() = default;
 
-  ~DISABLED_CudaBaseObjectsTest() = default;
+  ~CudaBaseObjectsTest() = default;
 };
 
-TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreate) {
+TEST_F(CudaBaseObjectsTest, piContextCreate) {
   pi_uint32 numPlatforms = 0;
   pi_platform platform = nullptr;
   pi_device device;
-  ASSERT_FALSE(Plugins.empty());
+  ASSERT_EQ(plugin.getBackend(), backend::cuda);
 
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
                 0, nullptr, &numPlatforms)),
             PI_SUCCESS)
       << "piPlatformsGet failed.\n";
 
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
                 numPlatforms, &platform, nullptr)),
             PI_SUCCESS)
       << "piPlatformsGet failed.\n";
@@ -49,13 +50,13 @@ TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreate) {
   ASSERT_GE(numPlatforms, 1u);
   ASSERT_NE(platform, nullptr);
 
-  ASSERT_EQ((Plugins[0].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((Plugins[0].call_nocheck<detail::PiApiKind::piContextCreate>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piContextCreate>(
                 nullptr, 1, &device, nullptr, nullptr, &ctxt)),
             PI_SUCCESS)
       << "piContextCreate failed.\n";
@@ -73,29 +74,29 @@ TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreate) {
   ASSERT_EQ(cuErr, CUDA_SUCCESS);
 }
 
-TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreatePrimaryTrue) {
+TEST_F(CudaBaseObjectsTest, piContextCreatePrimaryTrue) {
   pi_uint32 numPlatforms = 0;
   pi_platform platform;
   pi_device device;
 
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
                 0, nullptr, &numPlatforms)),
             PI_SUCCESS)
       << "piPlatformsGet failed.\n";
 
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
                 numPlatforms, &platform, nullptr)),
             PI_SUCCESS)
       << "piPlatformsGet failed.\n";
 
-  ASSERT_EQ((Plugins[0].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[] = {PI_CONTEXT_PROPERTIES_CUDA_PRIMARY,
                                         PI_TRUE, 0};
 
   pi_context ctxt;
-  ASSERT_EQ((Plugins[0].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);
@@ -114,34 +115,33 @@ TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreatePrimaryTrue) {
   cuErr = cuCtxGetCurrent(&current);
   ASSERT_EQ(cuErr, CUDA_SUCCESS);
   ASSERT_EQ(current, cudaContext);
-  ASSERT_EQ(
-      (Plugins[0].call_nocheck<detail::PiApiKind::piContextRelease>(ctxt)),
-      PI_SUCCESS);
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piContextRelease>(ctxt)),
+            PI_SUCCESS);
 }
 
-TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreatePrimaryFalse) {
+TEST_F(CudaBaseObjectsTest, piContextCreatePrimaryFalse) {
   pi_uint32 numPlatforms = 0;
   pi_platform platform;
   pi_device device;
 
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
                 0, nullptr, &numPlatforms)),
             PI_SUCCESS)
       << "piPlatformsGet failed.\n";
 
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
                 numPlatforms, &platform, nullptr)),
             PI_SUCCESS)
       << "piPlatformsGet failed.\n";
 
-  ASSERT_EQ((Plugins[0].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[] = {PI_CONTEXT_PROPERTIES_CUDA_PRIMARY,
                                         PI_FALSE, 0};
 
   pi_context ctxt;
-  ASSERT_EQ((Plugins[0].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,32 +160,31 @@ TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreatePrimaryFalse) {
   cuErr = cuCtxGetCurrent(&current);
   ASSERT_EQ(cuErr, CUDA_SUCCESS);
   ASSERT_EQ(current, cudaContext);
-  ASSERT_EQ(
-      (Plugins[0].call_nocheck<detail::PiApiKind::piContextRelease>(ctxt)),
-      PI_SUCCESS);
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piContextRelease>(ctxt)),
+            PI_SUCCESS);
 }
 
-TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreateChildThread) {
+TEST_F(CudaBaseObjectsTest, piContextCreateChildThread) {
   pi_uint32 numPlatforms = 0;
   pi_platform platform;
   pi_device device;
 
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
                 0, nullptr, &numPlatforms)),
             PI_SUCCESS)
       << "piPlatformsGet failed.\n";
 
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
                 numPlatforms, &platform, nullptr)),
             PI_SUCCESS)
       << "piPlatformsGet failed.\n";
 
-  ASSERT_EQ((Plugins[0].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((Plugins[0].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);
@@ -216,7 +215,6 @@ TEST_F(DISABLED_CudaBaseObjectsTest, piContextCreateChildThread) {
 
   callContextFromOtherThread.join();
 
-  ASSERT_EQ(
-      (Plugins[0].call_nocheck<detail::PiApiKind::piContextRelease>(ctxt)),
-      PI_SUCCESS);
+  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 cce61e9fdd418..5b0a424d02370 100644
--- a/sycl/unittests/pi/cuda/test_commands.cpp
+++ b/sycl/unittests/pi/cuda/test_commands.cpp
@@ -10,6 +10,7 @@
 
 #include <cuda.h>
 
+#include "test_get_plugin.hpp"
 #include <CL/sycl.hpp>
 #include <CL/sycl/detail/pi.hpp>
 #include <detail/plugin.hpp>
@@ -17,10 +18,10 @@
 
 using namespace cl::sycl;
 
-struct DISABLED_CudaCommandsTest : public ::testing::Test {
+struct CudaCommandsTest : public ::testing::Test {
 
 protected:
-  std::vector<detail::plugin> Plugins;
+  detail::plugin plugin = pi::initializeAndGetCuda();
 
   pi_platform platform_;
   pi_device device_;
@@ -30,27 +31,27 @@ struct DISABLED_CudaCommandsTest : public ::testing::Test {
   void SetUp() override {
     cuCtxSetCurrent(nullptr);
     pi_uint32 numPlatforms = 0;
-    ASSERT_FALSE(Plugins.empty());
+    ASSERT_EQ(plugin.getBackend(), backend::cuda);
 
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   0, nullptr, &numPlatforms)),
               PI_SUCCESS)
         << "piPlatformsGet failed.\n";
 
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   numPlatforms, &platform_, nullptr)),
               PI_SUCCESS)
         << "piPlatformsGet failed.\n";
 
-    ASSERT_EQ((Plugins[0].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((Plugins[0].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((Plugins[0].call_nocheck<detail::PiApiKind::piQueueCreate>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueCreate>(
                   context_, device_, 0, &queue_)),
               PI_SUCCESS);
     ASSERT_NE(queue_, nullptr);
@@ -59,32 +60,31 @@ struct DISABLED_CudaCommandsTest : public ::testing::Test {
   }
 
   void TearDown() override {
-    Plugins[0].call<detail::PiApiKind::piQueueRelease>(queue_);
-    Plugins[0].call<detail::PiApiKind::piContextRelease>(context_);
+    plugin.call<detail::PiApiKind::piQueueRelease>(queue_);
+    plugin.call<detail::PiApiKind::piContextRelease>(context_);
   }
 
-  DISABLED_CudaCommandsTest() { Plugins = detail::pi::initialize(); }
+  CudaCommandsTest() = default;
 
-  ~DISABLED_CudaCommandsTest() = default;
+  ~CudaCommandsTest() = default;
 };
 
-TEST_F(DISABLED_CudaCommandsTest, PIEnqueueReadBufferBlocking) {
+TEST_F(CudaCommandsTest, PIEnqueueReadBufferBlocking) {
   constexpr const size_t memSize = 10u;
   constexpr const size_t bytes = memSize * sizeof(int);
   const int data[memSize] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
   int output[memSize] = {};
 
   pi_mem memObj;
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piMemBufferCreate>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemBufferCreate>(
                 context_, PI_MEM_FLAGS_ACCESS_RW, bytes, nullptr, &memObj)),
             PI_SUCCESS);
 
-  ASSERT_EQ(
-      (Plugins[0].call_nocheck<detail::PiApiKind::piEnqueueMemBufferWrite>(
-          queue_, memObj, true, 0, bytes, data, 0, nullptr, nullptr)),
-      PI_SUCCESS);
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEnqueueMemBufferWrite>(
+                queue_, memObj, true, 0, bytes, data, 0, nullptr, nullptr)),
+            PI_SUCCESS);
 
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEnqueueMemBufferRead>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEnqueueMemBufferRead>(
                 queue_, memObj, true, 0, bytes, output, 0, nullptr, nullptr)),
             PI_SUCCESS);
 
@@ -98,32 +98,30 @@ TEST_F(DISABLED_CudaCommandsTest, PIEnqueueReadBufferBlocking) {
   }
 }
 
-TEST_F(DISABLED_CudaCommandsTest, PIEnqueueReadBufferNonBlocking) {
+TEST_F(CudaCommandsTest, PIEnqueueReadBufferNonBlocking) {
   constexpr const size_t memSize = 10u;
   constexpr const size_t bytes = memSize * sizeof(int);
   const int data[memSize] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
   int output[memSize] = {};
 
   pi_mem memObj;
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piMemBufferCreate>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemBufferCreate>(
                 context_, PI_MEM_FLAGS_ACCESS_RW, bytes, nullptr, &memObj)),
             PI_SUCCESS);
 
   pi_event cpIn, cpOut;
-  ASSERT_EQ(
-      (Plugins[0].call_nocheck<detail::PiApiKind::piEnqueueMemBufferWrite>(
-          queue_, memObj, false, 0, bytes, data, 0, nullptr, &cpIn)),
-      PI_SUCCESS);
+  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((Plugins[0].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(
-      (Plugins[0].call_nocheck<detail::PiApiKind::piEventsWait>(1, &cpOut)),
-      PI_SUCCESS);
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEventsWait>(1, &cpOut)),
+            PI_SUCCESS);
 
   bool isSame =
       std::equal(std::begin(output), std::end(output), std::begin(data));
diff --git a/sycl/unittests/pi/cuda/test_device.cpp b/sycl/unittests/pi/cuda/test_device.cpp
index d4f9e2bb01939..6b56ac8c2179b 100644
--- a/sycl/unittests/pi/cuda/test_device.cpp
+++ b/sycl/unittests/pi/cuda/test_device.cpp
@@ -10,6 +10,7 @@
 
 #include <cuda.h>
 
+#include "test_get_plugin.hpp"
 #include <CL/sycl.hpp>
 #include <CL/sycl/detail/pi.hpp>
 #include <detail/plugin.hpp>
@@ -17,10 +18,10 @@
 
 using namespace cl::sycl;
 
-struct DISABLED_CudaDeviceTests : public ::testing::Test {
+struct CudaDeviceTests : public ::testing::Test {
 
 protected:
-  std::vector<detail::plugin> Plugins;
+  detail::plugin plugin = pi::initializeAndGetCuda();
 
   pi_platform platform_;
   pi_device device_;
@@ -28,42 +29,41 @@ struct DISABLED_CudaDeviceTests : public ::testing::Test {
 
   void SetUp() override {
     pi_uint32 numPlatforms = 0;
-    ASSERT_FALSE(Plugins.empty());
+    ASSERT_EQ(plugin.getBackend(), backend::cuda);
 
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   0, nullptr, &numPlatforms)),
               PI_SUCCESS)
         << "piPlatformsGet failed.\n";
 
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   numPlatforms, &platform_, nullptr)),
               PI_SUCCESS)
         << "piPlatformsGet failed.\n";
 
-    ASSERT_EQ((Plugins[0].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((Plugins[0].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 {
-    Plugins[0].call<detail::PiApiKind::piDeviceRelease>(device_);
-    Plugins[0].call<detail::PiApiKind::piContextRelease>(context_);
+    plugin.call<detail::PiApiKind::piDeviceRelease>(device_);
+    plugin.call<detail::PiApiKind::piContextRelease>(context_);
   }
 
-  DISABLED_CudaDeviceTests() { detail::pi::initialize(); }
-
-  ~DISABLED_CudaDeviceTests() = default;
+  CudaDeviceTests() = default;
+  ~CudaDeviceTests() = default;
 };
 
-TEST_F(DISABLED_CudaDeviceTests, PIDeviceGetInfoSimple) {
+TEST_F(CudaDeviceTests, PIDeviceGetInfoSimple) {
 
   size_t return_size = 0;
   pi_device_type device_type;
-  ASSERT_EQ((Plugins[0].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 +73,7 @@ TEST_F(DISABLED_CudaDeviceTests, PIDeviceGetInfoSimple) {
       PI_DEVICE_TYPE_GPU); // backend pre-defined value, device must be a GPU
 
   pi_device parent_device = nullptr;
-  ASSERT_EQ((Plugins[0].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 +82,7 @@ TEST_F(DISABLED_CudaDeviceTests, PIDeviceGetInfoSimple) {
             nullptr); // backend pre-set value, device cannot have a parent
 
   pi_platform platform = nullptr;
-  ASSERT_EQ((Plugins[0].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 +91,7 @@ TEST_F(DISABLED_CudaDeviceTests, PIDeviceGetInfoSimple) {
                                   // test fixture platform
 
   cl_device_partition_property device_partition_property = -1;
-  ASSERT_EQ((Plugins[0].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_events.cpp b/sycl/unittests/pi/cuda/test_events.cpp
index e853cdd1c47c7..81c8664d8152b 100644
--- a/sycl/unittests/pi/cuda/test_events.cpp
+++ b/sycl/unittests/pi/cuda/test_events.cpp
@@ -10,6 +10,7 @@
 
 #include <cuda.h>
 
+#include "test_get_plugin.hpp"
 #include <CL/sycl.hpp>
 #include <CL/sycl/detail/pi.hpp>
 #include <detail/plugin.hpp>
@@ -19,76 +20,73 @@
 using namespace cl::sycl;
 
 namespace pi {
-class DISABLED_CudaEventTests : public ::testing::Test {
+class CudaEventTests : public ::testing::Test {
 protected:
-  std::vector<detail::plugin> Plugins;
+  detail::plugin plugin = pi::initializeAndGetCuda();
 
   pi_platform _platform;
   pi_context _context;
   pi_queue _queue;
   pi_device _device;
 
-  DISABLED_CudaEventTests()
-      : _context{nullptr}, _queue{nullptr}, _device{nullptr} {
-    Plugins = detail::pi::initialize();
-  }
+  CudaEventTests() : _context{nullptr}, _queue{nullptr}, _device{nullptr} {}
 
-  ~DISABLED_CudaEventTests() override = default;
+  ~CudaEventTests() override = default;
 
   void SetUp() override {
     pi_uint32 numPlatforms = 0;
-    ASSERT_FALSE(Plugins.empty());
+    ASSERT_EQ(plugin.getBackend(), backend::cuda);
 
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   0, nullptr, &numPlatforms)),
               PI_SUCCESS)
         << "piPlatformsGet failed.\n";
 
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   numPlatforms, &_platform, nullptr)),
               PI_SUCCESS)
         << "piPlatformsGet failed.\n";
 
-    ASSERT_EQ((Plugins[0].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((Plugins[0].call_nocheck<detail::PiApiKind::piContextCreate>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piContextCreate>(
                   nullptr, 1, &_device, nullptr, nullptr, &_context)),
               PI_SUCCESS);
 
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piQueueCreate>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueCreate>(
                   _context, _device, 0, &_queue)),
               PI_SUCCESS);
   }
 
   void TearDown() override {
-    Plugins[0].call<detail::PiApiKind::piQueueRelease>(_queue);
-    Plugins[0].call<detail::PiApiKind::piContextRelease>(_context);
+    plugin.call<detail::PiApiKind::piQueueRelease>(_queue);
+    plugin.call<detail::PiApiKind::piContextRelease>(_context);
   }
 };
 
-TEST_F(DISABLED_CudaEventTests, PICreateEvent) {
+TEST_F(CudaEventTests, PICreateEvent) {
 
   pi_event foo;
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventCreate>(_context,
-                                                                       &foo)),
-            PI_SUCCESS);
+  ASSERT_EQ(
+      (plugin.call_nocheck<detail::PiApiKind::piEventCreate>(_context, &foo)),
+      PI_SUCCESS);
   ASSERT_NE(foo, nullptr);
   // There is no CUDA interop event for user events
   EXPECT_EQ(foo->get(), nullptr);
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventRelease>(foo)),
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEventRelease>(foo)),
             PI_SUCCESS);
 }
 
-TEST_F(DISABLED_CudaEventTests, piGetInfoNativeEvent) {
+TEST_F(CudaEventTests, piGetInfoNativeEvent) {
 
   auto foo = _pi_event::make_native(PI_COMMAND_TYPE_NDRANGE_KERNEL, _queue);
   ASSERT_NE(foo, nullptr);
 
   pi_event_status paramValue = {};
   size_t retSize = 0u;
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventGetInfo>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEventGetInfo>(
                 foo, PI_EVENT_INFO_COMMAND_EXECUTION_STATUS, sizeof(paramValue),
                 &paramValue, &retSize)),
             PI_SUCCESS);
@@ -101,7 +99,7 @@ TEST_F(DISABLED_CudaEventTests, piGetInfoNativeEvent) {
   auto errCode = cuEventQuery(cuEvent);
   ASSERT_EQ(errCode, CUDA_SUCCESS);
 
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piEventRelease>(foo)),
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piEventRelease>(foo)),
             PI_SUCCESS);
 }
 } // namespace pi
diff --git a/sycl/unittests/pi/cuda/test_get_plugin.hpp b/sycl/unittests/pi/cuda/test_get_plugin.hpp
new file mode 100644
index 0000000000000..f050fa6f467a2
--- /dev/null
+++ b/sycl/unittests/pi/cuda/test_get_plugin.hpp
@@ -0,0 +1,21 @@
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#pragma once
+
+#include <detail/plugin.hpp>
+
+namespace pi {
+inline cl::sycl::detail::plugin initializeAndGetCuda() {
+  auto plugins = cl::sycl::detail::pi::initialize();
+  auto it = std::find_if(plugins.begin(), plugins.end(),
+                         [](cl::sycl::detail::plugin p) -> bool {
+                           return p.getBackend() == cl::sycl::backend::cuda;
+                         });
+  if (it == plugins.end()) {
+    throw std::runtime_error("PI CUDA plugin not found.");
+  }
+  return *it;
+}
+} // namespace pi
\ No newline at end of file
diff --git a/sycl/unittests/pi/cuda/test_interop_get_native.cpp b/sycl/unittests/pi/cuda/test_interop_get_native.cpp
index 1aec0b4c26ab0..81b6a27cbcc93 100644
--- a/sycl/unittests/pi/cuda/test_interop_get_native.cpp
+++ b/sycl/unittests/pi/cuda/test_interop_get_native.cpp
@@ -15,39 +15,41 @@
 
 using namespace cl::sycl;
 
-struct DISABLED_CudaInteropGetNativeTests : public ::testing::Test {
+struct CudaInteropGetNativeTests : public ::testing::Test {
 
 protected:
   queue syclQueue_;
   context syclContext_;
   device syclDevice_;
 
+  CudaInteropGetNativeTests()
+      : syclQueue_(cuda_device_selector()),
+        syclContext_(syclQueue_.get_context()),
+        syclDevice_(syclQueue_.get_device()) {}
+
   static bool isCudaDevice(const device &dev) {
     const platform platform = dev.get_info<info::device::platform>();
     const std::string platformVersion =
         platform.get_info<info::platform::version>();
+    const std::string platformName = platform.get_info<info::platform::name>();
     // If using PI_CUDA, don't accept a non-CUDA device
-    return platformVersion.find("CUDA") != std::string::npos;
+    return platformVersion.find("CUDA") != std::string::npos &&
+           platformName.find("NVIDIA CUDA") != std::string::npos;
   }
 
   class cuda_device_selector : public device_selector {
   public:
     int operator()(const device &dev) const {
-      return isCudaDevice(dev) ? 1 : -1;
+      return isCudaDevice(dev) ? 1000 : -1000;
     }
   };
 
-  void SetUp() override {
-    syclQueue_ = queue{cuda_device_selector()};
-    context syclContext_ = syclQueue_.get_context();
-    device syclDevice_ = syclQueue_.get_device();
-    ASSERT_TRUE(isCudaDevice(syclDevice_));
-  }
+  void SetUp() override {}
 
   void TearDown() override {}
 };
 
-TEST_F(DISABLED_CudaInteropGetNativeTests, getNativeDevice) {
+TEST_F(CudaInteropGetNativeTests, getNativeDevice) {
   CUdevice cudaDevice = get_native<backend::cuda>(syclDevice_);
   char cudaDeviceName[2] = {0, 0};
   CUresult result = cuDeviceGetName(cudaDeviceName, 2, cudaDevice);
@@ -55,12 +57,12 @@ TEST_F(DISABLED_CudaInteropGetNativeTests, getNativeDevice) {
   ASSERT_NE(cudaDeviceName[0], 0);
 }
 
-TEST_F(DISABLED_CudaInteropGetNativeTests, getNativeContext) {
+TEST_F(CudaInteropGetNativeTests, getNativeContext) {
   CUcontext cudaContext = get_native<backend::cuda>(syclContext_);
   ASSERT_NE(cudaContext, nullptr);
 }
 
-TEST_F(DISABLED_CudaInteropGetNativeTests, getNativeQueue) {
+TEST_F(CudaInteropGetNativeTests, getNativeQueue) {
   CUstream cudaStream = get_native<backend::cuda>(syclQueue_);
   ASSERT_NE(cudaStream, nullptr);
 
@@ -72,7 +74,7 @@ TEST_F(DISABLED_CudaInteropGetNativeTests, getNativeQueue) {
   ASSERT_EQ(streamContext, cudaContext);
 }
 
-TEST_F(DISABLED_CudaInteropGetNativeTests, interopTaskGetMem) {
+TEST_F(CudaInteropGetNativeTests, interopTaskGetMem) {
   buffer<int, 1> syclBuffer(range<1>{1});
   syclQueue_.submit([&](cl::sycl::handler &cgh) {
     auto syclAccessor = syclBuffer.get_access<access::mode::read>(cgh);
@@ -86,7 +88,7 @@ TEST_F(DISABLED_CudaInteropGetNativeTests, interopTaskGetMem) {
   });
 }
 
-TEST_F(DISABLED_CudaInteropGetNativeTests, interopTaskGetBufferMem) {
+TEST_F(CudaInteropGetNativeTests, interopTaskGetBufferMem) {
   CUstream cudaStream = get_native<backend::cuda>(syclQueue_);
   syclQueue_.submit([&](cl::sycl::handler &cgh) {
     cgh.interop_task([=](sycl::interop_handler ih) {
diff --git a/sycl/unittests/pi/cuda/test_kernels.cpp b/sycl/unittests/pi/cuda/test_kernels.cpp
index 7f302f532c708..afd95544e7ef9 100644
--- a/sycl/unittests/pi/cuda/test_kernels.cpp
+++ b/sycl/unittests/pi/cuda/test_kernels.cpp
@@ -10,6 +10,7 @@
 
 #include <cuda.h>
 
+#include "test_get_plugin.hpp"
 #include <CL/sycl.hpp>
 #include <CL/sycl/detail/pi.hpp>
 #include <detail/plugin.hpp>
@@ -17,11 +18,10 @@
 
 using namespace cl::sycl;
 
-struct DISABLED_CudaKernelsTest : public ::testing::Test {
+struct CudaKernelsTest : public ::testing::Test {
 
 protected:
-  std::vector<detail::plugin> Plugins;
-
+  detail::plugin plugin = pi::initializeAndGetCuda();
   pi_platform platform_;
   pi_device device_;
   pi_context context_;
@@ -29,27 +29,27 @@ struct DISABLED_CudaKernelsTest : public ::testing::Test {
 
   void SetUp() override {
     pi_uint32 numPlatforms = 0;
-    ASSERT_FALSE(Plugins.empty());
+    ASSERT_EQ(plugin.getBackend(), backend::cuda);
 
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   0, nullptr, &numPlatforms)),
               PI_SUCCESS)
         << "piPlatformsGet failed.\n";
 
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   numPlatforms, &platform_, nullptr)),
               PI_SUCCESS)
         << "piPlatformsGet failed.\n";
 
-    ASSERT_EQ((Plugins[0].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((Plugins[0].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((Plugins[0].call_nocheck<detail::PiApiKind::piQueueCreate>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueCreate>(
                   context_, device_, 0, &queue_)),
               PI_SUCCESS);
     ASSERT_NE(queue_, nullptr);
@@ -57,14 +57,14 @@ struct DISABLED_CudaKernelsTest : public ::testing::Test {
   }
 
   void TearDown() override {
-    Plugins[0].call<detail::PiApiKind::piDeviceRelease>(device_);
-    Plugins[0].call<detail::PiApiKind::piQueueRelease>(queue_);
-    Plugins[0].call<detail::PiApiKind::piContextRelease>(context_);
+    plugin.call<detail::PiApiKind::piDeviceRelease>(device_);
+    plugin.call<detail::PiApiKind::piQueueRelease>(queue_);
+    plugin.call<detail::PiApiKind::piContextRelease>(context_);
   }
 
-  DISABLED_CudaKernelsTest() { Plugins = detail::pi::initialize(); }
+  CudaKernelsTest() = default;
 
-  ~DISABLED_CudaKernelsTest() = default;
+  ~CudaKernelsTest() = default;
 };
 
 const char *ptxSource = "\n\
@@ -125,46 +125,44 @@ const char *threeParamsTwoLocal = "\n\
 }\n\
 ";
 
-
-
-TEST_F(DISABLED_CudaKernelsTest, PICreateProgramAndKernel) {
+TEST_F(CudaKernelsTest, PICreateProgramAndKernel) {
 
   pi_program prog;
   ASSERT_EQ(
-      (Plugins[0].call_nocheck<detail::PiApiKind::piclProgramCreateWithSource>(
+      (plugin.call_nocheck<detail::PiApiKind::piclProgramCreateWithSource>(
           context_, 1, (const char **)&ptxSource, nullptr, &prog)),
       PI_SUCCESS);
 
-  ASSERT_EQ((Plugins[0].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((Plugins[0].call_nocheck<detail::PiApiKind::piKernelCreate>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piKernelCreate>(
                 prog, "_Z8myKernelPi", &kern)),
             PI_SUCCESS);
   ASSERT_NE(kern, nullptr);
 }
 
-TEST_F(DISABLED_CudaKernelsTest, PIKernelArgumentSimple) {
+TEST_F(CudaKernelsTest, PIKernelArgumentSimple) {
 
   pi_program prog;
   ASSERT_EQ(
-      (Plugins[0].call_nocheck<detail::PiApiKind::piclProgramCreateWithSource>(
+      (plugin.call_nocheck<detail::PiApiKind::piclProgramCreateWithSource>(
           context_, 1, (const char **)&ptxSource, nullptr, &prog)),
       PI_SUCCESS);
 
-  ASSERT_EQ((Plugins[0].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((Plugins[0].call_nocheck<detail::PiApiKind::piKernelCreate>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piKernelCreate>(
                 prog, "_Z8myKernelPi", &kern)),
             PI_SUCCESS);
 
   int number = 10;
-  ASSERT_EQ((Plugins[0].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();
@@ -173,25 +171,25 @@ TEST_F(DISABLED_CudaKernelsTest, PIKernelArgumentSimple) {
   ASSERT_EQ(storedValue, number);
 }
 
-TEST_F(DISABLED_CudaKernelsTest, PIKernelArgumentSetTwice) {
+TEST_F(CudaKernelsTest, PIKernelArgumentSetTwice) {
 
   pi_program prog;
   ASSERT_EQ(
-      (Plugins[0].call_nocheck<detail::PiApiKind::piclProgramCreateWithSource>(
+      (plugin.call_nocheck<detail::PiApiKind::piclProgramCreateWithSource>(
           context_, 1, (const char **)&ptxSource, nullptr, &prog)),
       PI_SUCCESS);
 
-  ASSERT_EQ((Plugins[0].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((Plugins[0].call_nocheck<detail::PiApiKind::piKernelCreate>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piKernelCreate>(
                 prog, "_Z8myKernelPi", &kern)),
             PI_SUCCESS);
 
   int number = 10;
-  ASSERT_EQ((Plugins[0].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();
@@ -200,7 +198,7 @@ TEST_F(DISABLED_CudaKernelsTest, PIKernelArgumentSetTwice) {
   ASSERT_EQ(storedValue, number);
 
   int otherNumber = 934;
-  ASSERT_EQ((Plugins[0].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();
@@ -209,30 +207,30 @@ TEST_F(DISABLED_CudaKernelsTest, PIKernelArgumentSetTwice) {
   ASSERT_EQ(storedValue, otherNumber);
 }
 
-TEST_F(DISABLED_CudaKernelsTest, PIKernelSetMemObj) {
+TEST_F(CudaKernelsTest, PIKernelSetMemObj) {
 
   pi_program prog;
   ASSERT_EQ(
-      (Plugins[0].call_nocheck<detail::PiApiKind::piclProgramCreateWithSource>(
+      (plugin.call_nocheck<detail::PiApiKind::piclProgramCreateWithSource>(
           context_, 1, (const char **)&ptxSource, nullptr, &prog)),
       PI_SUCCESS);
 
-  ASSERT_EQ((Plugins[0].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((Plugins[0].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((Plugins[0].call_nocheck<detail::PiApiKind::piMemBufferCreate>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemBufferCreate>(
                 context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj)),
             PI_SUCCESS);
 
-  ASSERT_EQ((Plugins[0].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();
@@ -241,121 +239,116 @@ TEST_F(DISABLED_CudaKernelsTest, PIKernelSetMemObj) {
   ASSERT_EQ(storedValue, memObj);
 }
 
-TEST_F(DISABLED_CudaKernelsTest, PIkerneldispatch) {
+TEST_F(CudaKernelsTest, PIkerneldispatch) {
 
   pi_program prog;
   ASSERT_EQ(
-      (Plugins[0].call_nocheck<detail::PiApiKind::piclProgramCreateWithSource>(
+      (plugin.call_nocheck<detail::PiApiKind::piclProgramCreateWithSource>(
           context_, 1, (const char **)&ptxSource, nullptr, &prog)),
       PI_SUCCESS);
 
-  ASSERT_EQ((Plugins[0].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((Plugins[0].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((Plugins[0].call_nocheck<detail::PiApiKind::piMemBufferCreate>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemBufferCreate>(
                 context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj)),
             PI_SUCCESS);
 
-  ASSERT_EQ(
-      (Plugins[0].call_nocheck<detail::PiApiKind::piextKernelSetArgMemObj>(
-          kern, 0, &memObj)),
-      PI_SUCCESS);
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piextKernelSetArgMemObj>(
+                kern, 0, &memObj)),
+            PI_SUCCESS);
 
   size_t workDim = 1;
   size_t globalWorkOffset[] = {0};
   size_t globalWorkSize[] = {1};
   size_t localWorkSize[] = {1};
-  ASSERT_EQ((Plugins[0].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((Plugins[0].call_nocheck<detail::PiApiKind::piMemRelease>(memObj)),
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemRelease>(memObj)),
             PI_SUCCESS);
 }
 
-TEST_F(DISABLED_CudaKernelsTest, PIkerneldispatchTwo) {
+TEST_F(CudaKernelsTest, PIkerneldispatchTwo) {
 
   pi_program prog;
   ASSERT_EQ(
-      (Plugins[0].call_nocheck<detail::PiApiKind::piclProgramCreateWithSource>(
+      (plugin.call_nocheck<detail::PiApiKind::piclProgramCreateWithSource>(
           context_, 1, (const char **)&twoParams, nullptr, &prog)),
       PI_SUCCESS);
 
-  ASSERT_EQ((Plugins[0].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((Plugins[0].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((Plugins[0].call_nocheck<detail::PiApiKind::piMemBufferCreate>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemBufferCreate>(
                 context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj)),
             PI_SUCCESS);
 
   pi_mem memObj2;
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piMemBufferCreate>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemBufferCreate>(
                 context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj2)),
             PI_SUCCESS);
 
-  ASSERT_EQ(
-      (Plugins[0].call_nocheck<detail::PiApiKind::piextKernelSetArgMemObj>(
-          kern, 0, &memObj)),
-      PI_SUCCESS);
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piextKernelSetArgMemObj>(
+                kern, 0, &memObj)),
+            PI_SUCCESS);
 
-  ASSERT_EQ(
-      (Plugins[0].call_nocheck<detail::PiApiKind::piextKernelSetArgMemObj>(
-          kern, 1, &memObj2)),
-      PI_SUCCESS);
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piextKernelSetArgMemObj>(
+                kern, 1, &memObj2)),
+            PI_SUCCESS);
 
   size_t workDim = 1;
   size_t globalWorkOffset[] = {0};
   size_t globalWorkSize[] = {1};
   size_t localWorkSize[] = {1};
-  ASSERT_EQ((Plugins[0].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((Plugins[0].call_nocheck<detail::PiApiKind::piMemRelease>(memObj)),
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemRelease>(memObj)),
             PI_SUCCESS);
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piMemRelease>(memObj2)),
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemRelease>(memObj2)),
             PI_SUCCESS);
 }
 
-
-
-TEST_F(DISABLED_CudaKernelsTest, PIKernelArgumentSetTwiceOneLocal) {
+TEST_F(CudaKernelsTest, PIKernelArgumentSetTwiceOneLocal) {
 
   pi_program prog;
   ASSERT_EQ(
-      (Plugins[0].call_nocheck<detail::PiApiKind::piclProgramCreateWithSource>(
+      (plugin.call_nocheck<detail::PiApiKind::piclProgramCreateWithSource>(
           context_, 1, (const char **)&threeParamsTwoLocal, nullptr, &prog)),
       PI_SUCCESS);
 
-  ASSERT_EQ((Plugins[0].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((Plugins[0].call_nocheck<detail::PiApiKind::piKernelCreate>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piKernelCreate>(
                 prog, "twoParamKernelLocal", &kern)),
             PI_SUCCESS);
 
   int number = 10;
-  ASSERT_EQ((Plugins[0].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();
@@ -363,7 +356,7 @@ TEST_F(DISABLED_CudaKernelsTest, PIKernelArgumentSetTwiceOneLocal) {
   int storedValue = *(static_cast<const int *>(kernArgs[0]));
   ASSERT_EQ(storedValue, number);
 
-  ASSERT_EQ((Plugins[0].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();
@@ -371,12 +364,11 @@ TEST_F(DISABLED_CudaKernelsTest, PIKernelArgumentSetTwiceOneLocal) {
   storedValue = *(static_cast<const int *>(kernArgs2[1]));
   ASSERT_EQ(storedValue, 0);
 
-  ASSERT_EQ((Plugins[0].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();
   ASSERT_EQ(kernArgs3.size(), (size_t)3);
   storedValue = *(static_cast<const int *>(kernArgs3[2]));
   ASSERT_EQ(storedValue, static_cast<int>(sizeof(int)));
-
 }
diff --git a/sycl/unittests/pi/cuda/test_mem_obj.cpp b/sycl/unittests/pi/cuda/test_mem_obj.cpp
index 8adf994ae2bdc..dac5f28562d39 100644
--- a/sycl/unittests/pi/cuda/test_mem_obj.cpp
+++ b/sycl/unittests/pi/cuda/test_mem_obj.cpp
@@ -10,6 +10,7 @@
 
 #include <cuda.h>
 
+#include "test_get_plugin.hpp"
 #include <CL/sycl.hpp>
 #include <CL/sycl/detail/cuda_definitions.hpp>
 #include <CL/sycl/detail/pi.hpp>
@@ -18,10 +19,10 @@
 
 using namespace cl::sycl;
 
-struct DISABLED_CudaTestMemObj : public ::testing::Test {
+struct CudaTestMemObj : public ::testing::Test {
 
 protected:
-  std::vector<detail::plugin> Plugins;
+  detail::plugin plugin = pi::initializeAndGetCuda();
 
   pi_platform platform_;
   pi_device device_;
@@ -30,49 +31,49 @@ struct DISABLED_CudaTestMemObj : public ::testing::Test {
   void SetUp() override {
     cuCtxSetCurrent(nullptr);
     pi_uint32 numPlatforms = 0;
-    ASSERT_FALSE(Plugins.empty());
+    ASSERT_EQ(plugin.getBackend(), backend::cuda);
 
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   0, nullptr, &numPlatforms)),
               PI_SUCCESS)
         << "piPlatformsGet failed.\n";
 
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   numPlatforms, &platform_, nullptr)),
               PI_SUCCESS)
         << "piPlatformsGet failed.\n";
 
-    ASSERT_EQ((Plugins[0].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((Plugins[0].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 {
-    Plugins[0].call<detail::PiApiKind::piDeviceRelease>(device_);
-    Plugins[0].call<detail::PiApiKind::piContextRelease>(context_);
+    plugin.call<detail::PiApiKind::piDeviceRelease>(device_);
+    plugin.call<detail::PiApiKind::piContextRelease>(context_);
   }
 
-  DISABLED_CudaTestMemObj() { Plugins = detail::pi::initialize(); }
+  CudaTestMemObj() = default;
 
-  ~DISABLED_CudaTestMemObj() = default;
+  ~CudaTestMemObj() = default;
 };
 
-TEST_F(DISABLED_CudaTestMemObj, piMemBufferCreateSimple) {
+TEST_F(CudaTestMemObj, piMemBufferCreateSimple) {
   const size_t memSize = 1024u;
   pi_mem memObj;
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piMemBufferCreate>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemBufferCreate>(
                 context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj)),
             PI_SUCCESS);
 
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piMemRelease>(memObj)),
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemRelease>(memObj)),
             PI_SUCCESS);
 }
 
-TEST_F(DISABLED_CudaTestMemObj, piMemBufferCreateNoActiveContext) {
+TEST_F(CudaTestMemObj, piMemBufferCreateNoActiveContext) {
   const size_t memSize = 1024u;
   // Context has been destroyed
 
@@ -92,11 +93,11 @@ TEST_F(DISABLED_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((Plugins[0].call_nocheck<detail::PiApiKind::piMemBufferCreate>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemBufferCreate>(
                 context_, PI_MEM_FLAGS_ACCESS_RW, memSize, nullptr, &memObj)),
             PI_SUCCESS);
   ASSERT_NE(memObj, nullptr);
 
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piMemRelease>(memObj)),
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piMemRelease>(memObj)),
             PI_SUCCESS);
 }
diff --git a/sycl/unittests/pi/cuda/test_primary_context.cpp b/sycl/unittests/pi/cuda/test_primary_context.cpp
index 8e387cb4a2536..f23c0dddacb5e 100644
--- a/sycl/unittests/pi/cuda/test_primary_context.cpp
+++ b/sycl/unittests/pi/cuda/test_primary_context.cpp
@@ -10,6 +10,7 @@
 
 #include <cuda.h>
 
+#include "test_get_plugin.hpp"
 #include <CL/sycl.hpp>
 #include <CL/sycl/backend/cuda.hpp>
 #include <detail/plugin.hpp>
@@ -19,7 +20,7 @@
 
 using namespace cl::sycl;
 
-struct DISABLED_CudaPrimaryContextTests : public ::testing::Test {
+struct CudaPrimaryContextTests : public ::testing::Test {
 
 protected:
   device deviceA_;
@@ -77,7 +78,7 @@ struct DISABLED_CudaPrimaryContextTests : public ::testing::Test {
   void TearDown() override {}
 };
 
-TEST_F(DISABLED_CudaPrimaryContextTests, piSingleContext) {
+TEST_F(CudaPrimaryContextTests, piSingleContext) {
   std::cout << "create single context" << std::endl;
   context Context(deviceA_, async_handler{}, /*UsePrimaryContext=*/true);
 
@@ -92,7 +93,7 @@ TEST_F(DISABLED_CudaPrimaryContextTests, piSingleContext) {
   cuDevicePrimaryCtxRelease(CudaDevice);
 }
 
-TEST_F(DISABLED_CudaPrimaryContextTests, piMultiContextSingleDevice) {
+TEST_F(CudaPrimaryContextTests, piMultiContextSingleDevice) {
   std::cout << "create multiple contexts for one device" << std::endl;
   context ContextA(deviceA_, async_handler{}, /*UsePrimaryContext=*/true);
   context ContextB(deviceA_, async_handler{}, /*UsePrimaryContext=*/true);
@@ -103,7 +104,7 @@ TEST_F(DISABLED_CudaPrimaryContextTests, piMultiContextSingleDevice) {
   ASSERT_EQ(CudaContextA, CudaContextB);
 }
 
-TEST_F(DISABLED_CudaPrimaryContextTests, piMultiContextMultiDevice) {
+TEST_F(CudaPrimaryContextTests, piMultiContextMultiDevice) {
   CUdevice CudaDeviceA = deviceA_.get_native<backend::cuda>();
   CUdevice CudaDeviceB = deviceB_.get_native<backend::cuda>();
 
diff --git a/sycl/unittests/pi/cuda/test_queue.cpp b/sycl/unittests/pi/cuda/test_queue.cpp
index ca983e4c55c79..ce47ddb2d1d20 100644
--- a/sycl/unittests/pi/cuda/test_queue.cpp
+++ b/sycl/unittests/pi/cuda/test_queue.cpp
@@ -10,6 +10,7 @@
 
 #include <cuda.h>
 
+#include "test_get_plugin.hpp"
 #include <CL/sycl.hpp>
 #include <CL/sycl/detail/cuda_definitions.hpp>
 #include <CL/sycl/detail/pi.hpp>
@@ -18,10 +19,10 @@
 
 using namespace cl::sycl;
 
-struct DISABLED_CudaTestQueue : public ::testing::Test {
+struct CudaTestQueue : public ::testing::Test {
 
 protected:
-  std::vector<detail::plugin> Plugins;
+  detail::plugin plugin = pi::initializeAndGetCuda();
 
   pi_platform platform_;
   pi_device device_;
@@ -29,40 +30,40 @@ struct DISABLED_CudaTestQueue : public ::testing::Test {
 
   void SetUp() override {
     pi_uint32 numPlatforms = 0;
-    ASSERT_FALSE(Plugins.empty());
+    ASSERT_EQ(plugin.getBackend(), backend::cuda);
 
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   0, nullptr, &numPlatforms)),
               PI_SUCCESS)
         << "piPlatformsGet failed.\n";
 
-    ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piPlatformsGet>(
+    ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piPlatformsGet>(
                   numPlatforms, &platform_, nullptr)),
               PI_SUCCESS)
         << "piPlatformsGet failed.\n";
 
-    ASSERT_EQ((Plugins[0].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((Plugins[0].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 {
-    Plugins[0].call<detail::PiApiKind::piDeviceRelease>(device_);
-    Plugins[0].call<detail::PiApiKind::piContextRelease>(context_);
+    plugin.call<detail::PiApiKind::piDeviceRelease>(device_);
+    plugin.call<detail::PiApiKind::piContextRelease>(context_);
   }
 
-  DISABLED_CudaTestQueue() { detail::pi::initialize(); }
+  CudaTestQueue() = default;
 
-  ~DISABLED_CudaTestQueue() = default;
+  ~CudaTestQueue() = default;
 };
 
-TEST_F(DISABLED_CudaTestQueue, PICreateQueueSimple) {
+TEST_F(CudaTestQueue, PICreateQueueSimple) {
   pi_queue queue;
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piQueueCreate>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueCreate>(
                 context_, device_, 0, &queue)),
             PI_SUCCESS);
   ASSERT_NE(queue, nullptr);
@@ -73,13 +74,13 @@ TEST_F(DISABLED_CudaTestQueue, PICreateQueueSimple) {
   cuStreamGetFlags(stream, &flags);
   ASSERT_EQ(flags, CU_STREAM_NON_BLOCKING);
 
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piQueueRelease>(queue)),
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueRelease>(queue)),
             PI_SUCCESS);
 }
 
-TEST_F(DISABLED_CudaTestQueue, PIQueueFinishSimple) {
+TEST_F(CudaTestQueue, PIQueueFinishSimple) {
   pi_queue queue;
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piQueueCreate>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueCreate>(
                 context_, device_, 0, &queue)),
             PI_SUCCESS);
   ASSERT_NE(queue, nullptr);
@@ -87,18 +88,18 @@ TEST_F(DISABLED_CudaTestQueue, PIQueueFinishSimple) {
   // todo: post work on queue, ensure the results are valid and the work is
   // complete after piQueueFinish?
 
-  ASSERT_EQ((Plugins[0].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((Plugins[0].call_nocheck<detail::PiApiKind::piQueueRelease>(queue)),
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueRelease>(queue)),
             PI_SUCCESS);
 }
 
-TEST_F(DISABLED_CudaTestQueue, PICreateQueueSimpleDefault) {
+TEST_F(CudaTestQueue, PICreateQueueSimpleDefault) {
   pi_queue queue;
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piQueueCreate>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueCreate>(
                 context_, device_, PI_CUDA_USE_DEFAULT_STREAM, &queue)),
             PI_SUCCESS);
   ASSERT_NE(queue, nullptr);
@@ -109,13 +110,13 @@ TEST_F(DISABLED_CudaTestQueue, PICreateQueueSimpleDefault) {
   cuStreamGetFlags(stream, &flags);
   ASSERT_EQ(flags, CU_STREAM_DEFAULT);
 
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piQueueRelease>(queue)),
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueRelease>(queue)),
             PI_SUCCESS);
 }
 
-TEST_F(DISABLED_CudaTestQueue, PICreateQueueSyncWithDefault) {
+TEST_F(CudaTestQueue, PICreateQueueSyncWithDefault) {
   pi_queue queue;
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piQueueCreate>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueCreate>(
                 context_, device_, PI_CUDA_SYNC_WITH_DEFAULT, &queue)),
             PI_SUCCESS);
   ASSERT_NE(queue, nullptr);
@@ -126,13 +127,13 @@ TEST_F(DISABLED_CudaTestQueue, PICreateQueueSyncWithDefault) {
   cuStreamGetFlags(stream, &flags);
   ASSERT_NE(flags, CU_STREAM_NON_BLOCKING);
 
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piQueueRelease>(queue)),
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueRelease>(queue)),
             PI_SUCCESS);
 }
 
-TEST_F(DISABLED_CudaTestQueue, PICreateQueueInterop) {
+TEST_F(CudaTestQueue, PICreateQueueInterop) {
   pi_queue queue;
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piQueueCreate>(
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueCreate>(
                 context_, device_, 0, &queue)),
             PI_SUCCESS);
   ASSERT_NE(queue, nullptr);
@@ -145,6 +146,6 @@ TEST_F(DISABLED_CudaTestQueue, PICreateQueueInterop) {
   ASSERT_EQ(res, CUDA_SUCCESS);
   EXPECT_EQ(cuCtx, context_->get());
 
-  ASSERT_EQ((Plugins[0].call_nocheck<detail::PiApiKind::piQueueRelease>(queue)),
+  ASSERT_EQ((plugin.call_nocheck<detail::PiApiKind::piQueueRelease>(queue)),
             PI_SUCCESS);
 }